ROSE 0.11.145.272
generated.h
1#ifndef Rose_Traits_generated_h
2#define Rose_Traits_generated_h
3namespace Rose {
4namespace Traits {
5namespace generated {
6// Class: AccessModifier
7template <> struct describe_field_t<SgAccessModifier,SgAccessModifier::access_modifier_enum,&SgAccessModifier::p_modifier> {
10 static constexpr size_t position{0};
11 static constexpr char const * const name{"modifier"};
12 static constexpr char const * const typestr{"SgAccessModifier::access_modifier_enum"};
13 static constexpr bool traverse{false};
14 static constexpr auto mbr_ptr{&SgAccessModifier::p_modifier};
15 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16 using bind = Desc<SgAccessModifier, SgAccessModifier::access_modifier_enum SgAccessModifier::*, &SgAccessModifier::p_modifier>;
17};
18template <> struct describe_node_t<SgAccessModifier> {
19 using node = SgAccessModifier;
20 using base = SgModifier;
21 static constexpr char const * const name{"AccessModifier"};
22 static constexpr unsigned long variant{1};
23 static constexpr bool concrete{true};
26};
27template <> struct node_from_variant_t<1> { using type = SgAccessModifier; };
28
29// Class: ActualArgumentExpression
30template <> struct describe_field_t<SgActualArgumentExpression,SgName,&SgActualArgumentExpression::p_argument_name> {
32 using field_type = SgName;
33 static constexpr size_t position{0};
34 static constexpr char const * const name{"argument_name"};
35 static constexpr char const * const typestr{"SgName"};
36 static constexpr bool traverse{false};
37 static constexpr auto mbr_ptr{&SgActualArgumentExpression::p_argument_name};
38 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39 using bind = Desc<SgActualArgumentExpression, SgName SgActualArgumentExpression::*, &SgActualArgumentExpression::p_argument_name>;
40};
41template <> struct describe_field_t<SgActualArgumentExpression,SgExpression*,&SgActualArgumentExpression::p_expression> {
43 using field_type = SgExpression*;
44 static constexpr size_t position{1};
45 static constexpr char const * const name{"expression"};
46 static constexpr char const * const typestr{"SgExpression*"};
47 static constexpr bool traverse{true};
48 static constexpr auto mbr_ptr{&SgActualArgumentExpression::p_expression};
49 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
50 using bind = Desc<SgActualArgumentExpression, SgExpression* SgActualArgumentExpression::*, &SgActualArgumentExpression::p_expression>;
51};
54 using base = SgExpression;
55 static constexpr char const * const name{"ActualArgumentExpression"};
56 static constexpr unsigned long variant{2};
57 static constexpr bool concrete{true};
60};
61template <> struct node_from_variant_t<2> { using type = SgActualArgumentExpression; };
62
63// Class: AbsOp
64template <> struct describe_node_t<SgAbsOp> {
65 using node = SgAbsOp;
66 using base = SgUnaryOp;
67 static constexpr char const * const name{"AbsOp"};
68 static constexpr unsigned long variant{3};
69 static constexpr bool concrete{true};
71 using fields_t = mp::List<>;
72};
73template <> struct node_from_variant_t<3> { using type = SgAbsOp; };
74
75// Class: AdaAccessType
76template <> struct describe_field_t<SgAdaAccessType,SgType*,&SgAdaAccessType::p_base_type> {
77 using parent = SgAdaAccessType;
78 using field_type = SgType*;
79 static constexpr size_t position{0};
80 static constexpr char const * const name{"base_type"};
81 static constexpr char const * const typestr{"SgType*"};
82 static constexpr bool traverse{true};
83 static constexpr auto mbr_ptr{&SgAdaAccessType::p_base_type};
84 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
85 using bind = Desc<SgAdaAccessType, SgType* SgAdaAccessType::*, &SgAdaAccessType::p_base_type>;
86};
87template <> struct describe_field_t<SgAdaAccessType,bool,&SgAdaAccessType::p_is_general_access> {
88 using parent = SgAdaAccessType;
89 using field_type = bool;
90 static constexpr size_t position{1};
91 static constexpr char const * const name{"is_general_access"};
92 static constexpr char const * const typestr{"bool"};
93 static constexpr bool traverse{false};
94 static constexpr auto mbr_ptr{&SgAdaAccessType::p_is_general_access};
95 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
96 using bind = Desc<SgAdaAccessType, bool SgAdaAccessType::*, &SgAdaAccessType::p_is_general_access>;
97};
98template <> struct describe_field_t<SgAdaAccessType,bool,&SgAdaAccessType::p_is_anonymous> {
99 using parent = SgAdaAccessType;
100 using field_type = bool;
101 static constexpr size_t position{2};
102 static constexpr char const * const name{"is_anonymous"};
103 static constexpr char const * const typestr{"bool"};
104 static constexpr bool traverse{false};
105 static constexpr auto mbr_ptr{&SgAdaAccessType::p_is_anonymous};
106 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
107 using bind = Desc<SgAdaAccessType, bool SgAdaAccessType::*, &SgAdaAccessType::p_is_anonymous>;
108};
109template <> struct describe_node_t<SgAdaAccessType> {
110 using node = SgAdaAccessType;
111 using base = SgType;
112 static constexpr char const * const name{"AdaAccessType"};
113 static constexpr unsigned long variant{4};
114 static constexpr bool concrete{true};
115 using subclasses_t = mp::List<>;
117};
118template <> struct node_from_variant_t<4> { using type = SgAdaAccessType; };
119
120// Class: AdaAcceptStmt
121template <> struct describe_field_t<SgAdaAcceptStmt,SgFunctionParameterScope*,&SgAdaAcceptStmt::p_parameterScope> {
122 using parent = SgAdaAcceptStmt;
124 static constexpr size_t position{0};
125 static constexpr char const * const name{"parameterScope"};
126 static constexpr char const * const typestr{"SgFunctionParameterScope*"};
127 static constexpr bool traverse{false};
128 static constexpr auto mbr_ptr{&SgAdaAcceptStmt::p_parameterScope};
129 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
130 using bind = Desc<SgAdaAcceptStmt, SgFunctionParameterScope* SgAdaAcceptStmt::*, &SgAdaAcceptStmt::p_parameterScope>;
131};
132template <> struct describe_field_t<SgAdaAcceptStmt,SgFunctionParameterList*,&SgAdaAcceptStmt::p_parameterList> {
133 using parent = SgAdaAcceptStmt;
135 static constexpr size_t position{1};
136 static constexpr char const * const name{"parameterList"};
137 static constexpr char const * const typestr{"SgFunctionParameterList*"};
138 static constexpr bool traverse{true};
139 static constexpr auto mbr_ptr{&SgAdaAcceptStmt::p_parameterList};
140 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
141 using bind = Desc<SgAdaAcceptStmt, SgFunctionParameterList* SgAdaAcceptStmt::*, &SgAdaAcceptStmt::p_parameterList>;
142};
143template <> struct describe_field_t<SgAdaAcceptStmt,SgExpression*,&SgAdaAcceptStmt::p_entry> {
144 using parent = SgAdaAcceptStmt;
145 using field_type = SgExpression*;
146 static constexpr size_t position{2};
147 static constexpr char const * const name{"entry"};
148 static constexpr char const * const typestr{"SgExpression*"};
149 static constexpr bool traverse{true};
150 static constexpr auto mbr_ptr{&SgAdaAcceptStmt::p_entry};
151 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
152 using bind = Desc<SgAdaAcceptStmt, SgExpression* SgAdaAcceptStmt::*, &SgAdaAcceptStmt::p_entry>;
153};
154template <> struct describe_field_t<SgAdaAcceptStmt,SgExpression*,&SgAdaAcceptStmt::p_index> {
155 using parent = SgAdaAcceptStmt;
156 using field_type = SgExpression*;
157 static constexpr size_t position{3};
158 static constexpr char const * const name{"index"};
159 static constexpr char const * const typestr{"SgExpression*"};
160 static constexpr bool traverse{true};
161 static constexpr auto mbr_ptr{&SgAdaAcceptStmt::p_index};
162 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
163 using bind = Desc<SgAdaAcceptStmt, SgExpression* SgAdaAcceptStmt::*, &SgAdaAcceptStmt::p_index>;
164};
165template <> struct describe_field_t<SgAdaAcceptStmt,SgStatement*,&SgAdaAcceptStmt::p_body> {
166 using parent = SgAdaAcceptStmt;
167 using field_type = SgStatement*;
168 static constexpr size_t position{4};
169 static constexpr char const * const name{"body"};
170 static constexpr char const * const typestr{"SgStatement*"};
171 static constexpr bool traverse{true};
172 static constexpr auto mbr_ptr{&SgAdaAcceptStmt::p_body};
173 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
174 using bind = Desc<SgAdaAcceptStmt, SgStatement* SgAdaAcceptStmt::*, &SgAdaAcceptStmt::p_body>;
175};
185template <> struct node_from_variant_t<5> { using type = SgAdaAcceptStmt; };
186
187// Class: AdaDelayStmt
188template <> struct describe_field_t<SgAdaDelayStmt,SgExpression*,&SgAdaDelayStmt::p_time> {
189 using parent = SgAdaDelayStmt;
190 using field_type = SgExpression*;
191 static constexpr size_t position{0};
192 static constexpr char const * const name{"time"};
193 static constexpr char const * const typestr{"SgExpression*"};
194 static constexpr bool traverse{true};
195 static constexpr auto mbr_ptr{&SgAdaDelayStmt::p_time};
196 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
197 using bind = Desc<SgAdaDelayStmt, SgExpression* SgAdaDelayStmt::*, &SgAdaDelayStmt::p_time>;
198};
199template <> struct describe_field_t<SgAdaDelayStmt,bool,&SgAdaDelayStmt::p_isRelative> {
200 using parent = SgAdaDelayStmt;
201 using field_type = bool;
202 static constexpr size_t position{1};
203 static constexpr char const * const name{"isRelative"};
204 static constexpr char const * const typestr{"bool"};
205 static constexpr bool traverse{false};
206 static constexpr auto mbr_ptr{&SgAdaDelayStmt::p_isRelative};
207 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
208 using bind = Desc<SgAdaDelayStmt, bool SgAdaDelayStmt::*, &SgAdaDelayStmt::p_isRelative>;
209};
210template <> struct describe_node_t<SgAdaDelayStmt> {
211 using node = SgAdaDelayStmt;
212 using base = SgStatement;
213 static constexpr char const * const name{"AdaDelayStmt"};
214 static constexpr unsigned long variant{6};
215 static constexpr bool concrete{true};
216 using subclasses_t = mp::List<>;
218};
219template <> struct node_from_variant_t<6> { using type = SgAdaDelayStmt; };
220
221// Class: AdaEntryDecl
222template <> struct describe_field_t<SgAdaEntryDecl,SgInitializedName*,&SgAdaEntryDecl::p_entryIndex> {
223 using parent = SgAdaEntryDecl;
225 static constexpr size_t position{0};
226 static constexpr char const * const name{"entryIndex"};
227 static constexpr char const * const typestr{"SgInitializedName*"};
228 static constexpr bool traverse{true};
229 static constexpr auto mbr_ptr{&SgAdaEntryDecl::p_entryIndex};
230 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
231 using bind = Desc<SgAdaEntryDecl, SgInitializedName* SgAdaEntryDecl::*, &SgAdaEntryDecl::p_entryIndex>;
232};
233template <> struct describe_field_t<SgAdaEntryDecl,SgExpression*,&SgAdaEntryDecl::p_entryBarrier> {
234 using parent = SgAdaEntryDecl;
235 using field_type = SgExpression*;
236 static constexpr size_t position{1};
237 static constexpr char const * const name{"entryBarrier"};
238 static constexpr char const * const typestr{"SgExpression*"};
239 static constexpr bool traverse{true};
240 static constexpr auto mbr_ptr{&SgAdaEntryDecl::p_entryBarrier};
241 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
242 using bind = Desc<SgAdaEntryDecl, SgExpression* SgAdaEntryDecl::*, &SgAdaEntryDecl::p_entryBarrier>;
243};
244template <> struct describe_node_t<SgAdaEntryDecl> {
245 using node = SgAdaEntryDecl;
247 static constexpr char const * const name{"AdaEntryDecl"};
248 static constexpr unsigned long variant{7};
249 static constexpr bool concrete{true};
250 using subclasses_t = mp::List<>;
252};
253template <> struct node_from_variant_t<7> { using type = SgAdaEntryDecl; };
254
255// Class: AdaExitStmt
256template <> struct describe_field_t<SgAdaExitStmt,SgStatement*,&SgAdaExitStmt::p_loop> {
257 using parent = SgAdaExitStmt;
258 using field_type = SgStatement*;
259 static constexpr size_t position{0};
260 static constexpr char const * const name{"loop"};
261 static constexpr char const * const typestr{"SgStatement*"};
262 static constexpr bool traverse{false};
263 static constexpr auto mbr_ptr{&SgAdaExitStmt::p_loop};
264 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
265 using bind = Desc<SgAdaExitStmt, SgStatement* SgAdaExitStmt::*, &SgAdaExitStmt::p_loop>;
266};
267template <> struct describe_field_t<SgAdaExitStmt,SgExpression*,&SgAdaExitStmt::p_condition> {
268 using parent = SgAdaExitStmt;
269 using field_type = SgExpression*;
270 static constexpr size_t position{1};
271 static constexpr char const * const name{"condition"};
272 static constexpr char const * const typestr{"SgExpression*"};
273 static constexpr bool traverse{true};
274 static constexpr auto mbr_ptr{&SgAdaExitStmt::p_condition};
275 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
276 using bind = Desc<SgAdaExitStmt, SgExpression* SgAdaExitStmt::*, &SgAdaExitStmt::p_condition>;
277};
278template <> struct describe_field_t<SgAdaExitStmt,bool,&SgAdaExitStmt::p_explicitLoopName> {
279 using parent = SgAdaExitStmt;
280 using field_type = bool;
281 static constexpr size_t position{2};
282 static constexpr char const * const name{"explicitLoopName"};
283 static constexpr char const * const typestr{"bool"};
284 static constexpr bool traverse{false};
285 static constexpr auto mbr_ptr{&SgAdaExitStmt::p_explicitLoopName};
286 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
287 using bind = Desc<SgAdaExitStmt, bool SgAdaExitStmt::*, &SgAdaExitStmt::p_explicitLoopName>;
288};
289template <> struct describe_node_t<SgAdaExitStmt> {
290 using node = SgAdaExitStmt;
291 using base = SgStatement;
292 static constexpr char const * const name{"AdaExitStmt"};
293 static constexpr unsigned long variant{8};
294 static constexpr bool concrete{true};
295 using subclasses_t = mp::List<>;
297};
298template <> struct node_from_variant_t<8> { using type = SgAdaExitStmt; };
299
300// Class: AdaDiscreteType
302 using node = SgAdaDiscreteType;
303 using base = SgType;
304 static constexpr char const * const name{"AdaDiscreteType"};
305 static constexpr unsigned long variant{9};
306 static constexpr bool concrete{true};
307 using subclasses_t = mp::List<>;
308 using fields_t = mp::List<>;
309};
310template <> struct node_from_variant_t<9> { using type = SgAdaDiscreteType; };
311
312// Class: AdaFloatVal
313template <> struct describe_field_t<SgAdaFloatVal,std::string,&SgAdaFloatVal::p_valueString> {
314 using parent = SgAdaFloatVal;
315 using field_type = std::string;
316 static constexpr size_t position{0};
317 static constexpr char const * const name{"valueString"};
318 static constexpr char const * const typestr{"std::string"};
319 static constexpr bool traverse{false};
320 static constexpr auto mbr_ptr{&SgAdaFloatVal::p_valueString};
321 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
322 using bind = Desc<SgAdaFloatVal, std::string SgAdaFloatVal::*, &SgAdaFloatVal::p_valueString>;
323};
324template <> struct describe_node_t<SgAdaFloatVal> {
325 using node = SgAdaFloatVal;
326 using base = SgValueExp;
327 static constexpr char const * const name{"AdaFloatVal"};
328 static constexpr unsigned long variant{10};
329 static constexpr bool concrete{true};
330 using subclasses_t = mp::List<>;
332};
333template <> struct node_from_variant_t<10> { using type = SgAdaFloatVal; };
334
335// Class: AdaLoopStmt
336template <> struct describe_field_t<SgAdaLoopStmt,SgBasicBlock*,&SgAdaLoopStmt::p_body> {
337 using parent = SgAdaLoopStmt;
338 using field_type = SgBasicBlock*;
339 static constexpr size_t position{0};
340 static constexpr char const * const name{"body"};
341 static constexpr char const * const typestr{"SgBasicBlock*"};
342 static constexpr bool traverse{true};
343 static constexpr auto mbr_ptr{&SgAdaLoopStmt::p_body};
344 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
345 using bind = Desc<SgAdaLoopStmt, SgBasicBlock* SgAdaLoopStmt::*, &SgAdaLoopStmt::p_body>;
346};
347template <> struct describe_field_t<SgAdaLoopStmt,std::string,&SgAdaLoopStmt::p_string_label> {
348 using parent = SgAdaLoopStmt;
349 using field_type = std::string;
350 static constexpr size_t position{1};
351 static constexpr char const * const name{"string_label"};
352 static constexpr char const * const typestr{"std::string"};
353 static constexpr bool traverse{false};
354 static constexpr auto mbr_ptr{&SgAdaLoopStmt::p_string_label};
355 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
356 using bind = Desc<SgAdaLoopStmt, std::string SgAdaLoopStmt::*, &SgAdaLoopStmt::p_string_label>;
357};
358template <> struct describe_node_t<SgAdaLoopStmt> {
359 using node = SgAdaLoopStmt;
360 using base = SgStatement;
361 static constexpr char const * const name{"AdaLoopStmt"};
362 static constexpr unsigned long variant{11};
363 static constexpr bool concrete{true};
364 using subclasses_t = mp::List<>;
366};
367template <> struct node_from_variant_t<11> { using type = SgAdaLoopStmt; };
368
369// Class: AdaPackageBody
370template <> struct describe_field_t<SgAdaPackageBody,SgStatementPtrList,&SgAdaPackageBody::p_statements> {
371 using parent = SgAdaPackageBody;
372 using field_type = SgStatementPtrList;
373 static constexpr size_t position{0};
374 static constexpr char const * const name{"statements"};
375 static constexpr char const * const typestr{"SgStatementPtrList"};
376 static constexpr bool traverse{true};
377 static constexpr auto mbr_ptr{&SgAdaPackageBody::p_statements};
378 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
379 using bind = Desc<SgAdaPackageBody, SgStatementPtrList SgAdaPackageBody::*, &SgAdaPackageBody::p_statements>;
380};
382 using node = SgAdaPackageBody;
383 using base = SgScopeStatement;
384 static constexpr char const * const name{"AdaPackageBody"};
385 static constexpr unsigned long variant{12};
386 static constexpr bool concrete{true};
387 using subclasses_t = mp::List<>;
389};
390template <> struct node_from_variant_t<12> { using type = SgAdaPackageBody; };
391
392// Class: AdaPackageBodyDecl
393template <> struct describe_field_t<SgAdaPackageBodyDecl,SgName,&SgAdaPackageBodyDecl::p_name> {
395 using field_type = SgName;
396 static constexpr size_t position{0};
397 static constexpr char const * const name{"name"};
398 static constexpr char const * const typestr{"SgName"};
399 static constexpr bool traverse{false};
400 static constexpr auto mbr_ptr{&SgAdaPackageBodyDecl::p_name};
401 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
402 using bind = Desc<SgAdaPackageBodyDecl, SgName SgAdaPackageBodyDecl::*, &SgAdaPackageBodyDecl::p_name>;
403};
404template <> struct describe_field_t<SgAdaPackageBodyDecl,SgAdaPackageBody*,&SgAdaPackageBodyDecl::p_definition> {
407 static constexpr size_t position{1};
408 static constexpr char const * const name{"definition"};
409 static constexpr char const * const typestr{"SgAdaPackageBody*"};
410 static constexpr bool traverse{true};
411 static constexpr auto mbr_ptr{&SgAdaPackageBodyDecl::p_definition};
412 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
413 using bind = Desc<SgAdaPackageBodyDecl, SgAdaPackageBody* SgAdaPackageBodyDecl::*, &SgAdaPackageBodyDecl::p_definition>;
414};
415template <> struct describe_field_t<SgAdaPackageBodyDecl,SgScopeStatement*,&SgAdaPackageBodyDecl::p_scope> {
418 static constexpr size_t position{2};
419 static constexpr char const * const name{"scope"};
420 static constexpr char const * const typestr{"SgScopeStatement*"};
421 static constexpr bool traverse{false};
422 static constexpr auto mbr_ptr{&SgAdaPackageBodyDecl::p_scope};
423 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
424 using bind = Desc<SgAdaPackageBodyDecl, SgScopeStatement* SgAdaPackageBodyDecl::*, &SgAdaPackageBodyDecl::p_scope>;
425};
426template <> struct describe_field_t<SgAdaPackageBodyDecl,SgAdaPackageSpecDecl*,&SgAdaPackageBodyDecl::p_spec> {
429 static constexpr size_t position{3};
430 static constexpr char const * const name{"spec"};
431 static constexpr char const * const typestr{"SgAdaPackageSpecDecl*"};
432 static constexpr bool traverse{false};
433 static constexpr auto mbr_ptr{&SgAdaPackageBodyDecl::p_spec};
434 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
435 using bind = Desc<SgAdaPackageBodyDecl, SgAdaPackageSpecDecl* SgAdaPackageBodyDecl::*, &SgAdaPackageBodyDecl::p_spec>;
436};
446template <> struct node_from_variant_t<13> { using type = SgAdaPackageBodyDecl; };
447
448// Class: AdaPackageSpec
449template <> struct describe_field_t<SgAdaPackageSpec,bool,&SgAdaPackageSpec::p_hasPrivate> {
450 using parent = SgAdaPackageSpec;
451 using field_type = bool;
452 static constexpr size_t position{0};
453 static constexpr char const * const name{"hasPrivate"};
454 static constexpr char const * const typestr{"bool"};
455 static constexpr bool traverse{false};
456 static constexpr auto mbr_ptr{&SgAdaPackageSpec::p_hasPrivate};
457 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
458 using bind = Desc<SgAdaPackageSpec, bool SgAdaPackageSpec::*, &SgAdaPackageSpec::p_hasPrivate>;
459};
460template <> struct describe_field_t<SgAdaPackageSpec,SgDeclarationStatementPtrList,&SgAdaPackageSpec::p_declarations> {
461 using parent = SgAdaPackageSpec;
462 using field_type = SgDeclarationStatementPtrList;
463 static constexpr size_t position{1};
464 static constexpr char const * const name{"declarations"};
465 static constexpr char const * const typestr{"SgDeclarationStatementPtrList"};
466 static constexpr bool traverse{true};
467 static constexpr auto mbr_ptr{&SgAdaPackageSpec::p_declarations};
468 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
469 using bind = Desc<SgAdaPackageSpec, SgDeclarationStatementPtrList SgAdaPackageSpec::*, &SgAdaPackageSpec::p_declarations>;
470};
472 using node = SgAdaPackageSpec;
473 using base = SgScopeStatement;
474 static constexpr char const * const name{"AdaPackageSpec"};
475 static constexpr unsigned long variant{14};
476 static constexpr bool concrete{true};
477 using subclasses_t = mp::List<>;
479};
480template <> struct node_from_variant_t<14> { using type = SgAdaPackageSpec; };
481
482// Class: AdaPackageSpecDecl
483template <> struct describe_field_t<SgAdaPackageSpecDecl,SgName,&SgAdaPackageSpecDecl::p_name> {
485 using field_type = SgName;
486 static constexpr size_t position{0};
487 static constexpr char const * const name{"name"};
488 static constexpr char const * const typestr{"SgName"};
489 static constexpr bool traverse{false};
490 static constexpr auto mbr_ptr{&SgAdaPackageSpecDecl::p_name};
491 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
492 using bind = Desc<SgAdaPackageSpecDecl, SgName SgAdaPackageSpecDecl::*, &SgAdaPackageSpecDecl::p_name>;
493};
494template <> struct describe_field_t<SgAdaPackageSpecDecl,SgAdaPackageSpec*,&SgAdaPackageSpecDecl::p_definition> {
497 static constexpr size_t position{1};
498 static constexpr char const * const name{"definition"};
499 static constexpr char const * const typestr{"SgAdaPackageSpec*"};
500 static constexpr bool traverse{true};
501 static constexpr auto mbr_ptr{&SgAdaPackageSpecDecl::p_definition};
502 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
503 using bind = Desc<SgAdaPackageSpecDecl, SgAdaPackageSpec* SgAdaPackageSpecDecl::*, &SgAdaPackageSpecDecl::p_definition>;
504};
505template <> struct describe_field_t<SgAdaPackageSpecDecl,SgScopeStatement*,&SgAdaPackageSpecDecl::p_scope> {
508 static constexpr size_t position{2};
509 static constexpr char const * const name{"scope"};
510 static constexpr char const * const typestr{"SgScopeStatement*"};
511 static constexpr bool traverse{false};
512 static constexpr auto mbr_ptr{&SgAdaPackageSpecDecl::p_scope};
513 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
514 using bind = Desc<SgAdaPackageSpecDecl, SgScopeStatement* SgAdaPackageSpecDecl::*, &SgAdaPackageSpecDecl::p_scope>;
515};
516template <> struct describe_field_t<SgAdaPackageSpecDecl,SgAdaPackageBodyDecl*,&SgAdaPackageSpecDecl::p_body> {
519 static constexpr size_t position{3};
520 static constexpr char const * const name{"body"};
521 static constexpr char const * const typestr{"SgAdaPackageBodyDecl*"};
522 static constexpr bool traverse{false};
523 static constexpr auto mbr_ptr{&SgAdaPackageSpecDecl::p_body};
524 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
525 using bind = Desc<SgAdaPackageSpecDecl, SgAdaPackageBodyDecl* SgAdaPackageSpecDecl::*, &SgAdaPackageSpecDecl::p_body>;
526};
536template <> struct node_from_variant_t<15> { using type = SgAdaPackageSpecDecl; };
537
538// Class: AdaPackageSymbol
539template <> struct describe_field_t<SgAdaPackageSymbol,SgDeclarationStatement*,&SgAdaPackageSymbol::p_declaration> {
542 static constexpr size_t position{0};
543 static constexpr char const * const name{"declaration"};
544 static constexpr char const * const typestr{"SgDeclarationStatement*"};
545 static constexpr bool traverse{true};
546 static constexpr auto mbr_ptr{&SgAdaPackageSymbol::p_declaration};
547 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
548 using bind = Desc<SgAdaPackageSymbol, SgDeclarationStatement* SgAdaPackageSymbol::*, &SgAdaPackageSymbol::p_declaration>;
549};
551 using node = SgAdaPackageSymbol;
552 using base = SgSymbol;
553 static constexpr char const * const name{"AdaPackageSymbol"};
554 static constexpr unsigned long variant{16};
555 static constexpr bool concrete{true};
556 using subclasses_t = mp::List<>;
558};
559template <> struct node_from_variant_t<16> { using type = SgAdaPackageSymbol; };
560
561// Class: AdaRangeConstraint
562template <> struct describe_field_t<SgAdaRangeConstraint,SgExpression*,&SgAdaRangeConstraint::p_range> {
564 using field_type = SgExpression*;
565 static constexpr size_t position{0};
566 static constexpr char const * const name{"range"};
567 static constexpr char const * const typestr{"SgExpression*"};
568 static constexpr bool traverse{true};
569 static constexpr auto mbr_ptr{&SgAdaRangeConstraint::p_range};
570 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
571 using bind = Desc<SgAdaRangeConstraint, SgExpression* SgAdaRangeConstraint::*, &SgAdaRangeConstraint::p_range>;
572};
576 static constexpr char const * const name{"AdaRangeConstraint"};
577 static constexpr unsigned long variant{17};
578 static constexpr bool concrete{true};
579 using subclasses_t = mp::List<>;
581};
582template <> struct node_from_variant_t<17> { using type = SgAdaRangeConstraint; };
583
584// Class: AdaRenamingDecl
585template <> struct describe_field_t<SgAdaRenamingDecl,SgName,&SgAdaRenamingDecl::p_name> {
587 using field_type = SgName;
588 static constexpr size_t position{0};
589 static constexpr char const * const name{"name"};
590 static constexpr char const * const typestr{"SgName"};
591 static constexpr bool traverse{false};
592 static constexpr auto mbr_ptr{&SgAdaRenamingDecl::p_name};
593 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
594 using bind = Desc<SgAdaRenamingDecl, SgName SgAdaRenamingDecl::*, &SgAdaRenamingDecl::p_name>;
595};
596template <> struct describe_field_t<SgAdaRenamingDecl,SgExpression*,&SgAdaRenamingDecl::p_renamed> {
598 using field_type = SgExpression*;
599 static constexpr size_t position{1};
600 static constexpr char const * const name{"renamed"};
601 static constexpr char const * const typestr{"SgExpression*"};
602 static constexpr bool traverse{true};
603 static constexpr auto mbr_ptr{&SgAdaRenamingDecl::p_renamed};
604 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
605 using bind = Desc<SgAdaRenamingDecl, SgExpression* SgAdaRenamingDecl::*, &SgAdaRenamingDecl::p_renamed>;
606};
607template <> struct describe_field_t<SgAdaRenamingDecl,SgType*,&SgAdaRenamingDecl::p_type> {
609 using field_type = SgType*;
610 static constexpr size_t position{2};
611 static constexpr char const * const name{"type"};
612 static constexpr char const * const typestr{"SgType*"};
613 static constexpr bool traverse{false};
614 static constexpr auto mbr_ptr{&SgAdaRenamingDecl::p_type};
615 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
616 using bind = Desc<SgAdaRenamingDecl, SgType* SgAdaRenamingDecl::*, &SgAdaRenamingDecl::p_type>;
617};
619 using node = SgAdaRenamingDecl;
621 static constexpr char const * const name{"AdaRenamingDecl"};
622 static constexpr unsigned long variant{18};
623 static constexpr bool concrete{true};
624 using subclasses_t = mp::List<>;
626};
627template <> struct node_from_variant_t<18> { using type = SgAdaRenamingDecl; };
628
629// Class: AdaSubtype
630template <> struct describe_field_t<SgAdaSubtype,SgType*,&SgAdaSubtype::p_base_type> {
631 using parent = SgAdaSubtype;
632 using field_type = SgType*;
633 static constexpr size_t position{0};
634 static constexpr char const * const name{"base_type"};
635 static constexpr char const * const typestr{"SgType*"};
636 static constexpr bool traverse{true};
637 static constexpr auto mbr_ptr{&SgAdaSubtype::p_base_type};
638 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
639 using bind = Desc<SgAdaSubtype, SgType* SgAdaSubtype::*, &SgAdaSubtype::p_base_type>;
640};
641template <> struct describe_field_t<SgAdaSubtype,SgAdaTypeConstraint*,&SgAdaSubtype::p_constraint> {
642 using parent = SgAdaSubtype;
644 static constexpr size_t position{1};
645 static constexpr char const * const name{"constraint"};
646 static constexpr char const * const typestr{"SgAdaTypeConstraint*"};
647 static constexpr bool traverse{true};
648 static constexpr auto mbr_ptr{&SgAdaSubtype::p_constraint};
649 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
650 using bind = Desc<SgAdaSubtype, SgAdaTypeConstraint* SgAdaSubtype::*, &SgAdaSubtype::p_constraint>;
651};
652template <> struct describe_field_t<SgAdaSubtype,bool,&SgAdaSubtype::p_fromRootType> {
653 using parent = SgAdaSubtype;
654 using field_type = bool;
655 static constexpr size_t position{2};
656 static constexpr char const * const name{"fromRootType"};
657 static constexpr char const * const typestr{"bool"};
658 static constexpr bool traverse{false};
659 static constexpr auto mbr_ptr{&SgAdaSubtype::p_fromRootType};
660 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
661 using bind = Desc<SgAdaSubtype, bool SgAdaSubtype::*, &SgAdaSubtype::p_fromRootType>;
662};
663template <> struct describe_node_t<SgAdaSubtype> {
664 using node = SgAdaSubtype;
665 using base = SgType;
666 static constexpr char const * const name{"AdaSubtype"};
667 static constexpr unsigned long variant{19};
668 static constexpr bool concrete{true};
669 using subclasses_t = mp::List<>;
671};
672template <> struct node_from_variant_t<19> { using type = SgAdaSubtype; };
673
674// Class: AdaTaskBody
675template <> struct describe_field_t<SgAdaTaskBody,SgAdaTaskSpec*,&SgAdaTaskBody::p_spec> {
676 using parent = SgAdaTaskBody;
677 using field_type = SgAdaTaskSpec*;
678 static constexpr size_t position{0};
679 static constexpr char const * const name{"spec"};
680 static constexpr char const * const typestr{"SgAdaTaskSpec*"};
681 static constexpr bool traverse{false};
682 static constexpr auto mbr_ptr{&SgAdaTaskBody::p_spec};
683 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
684 using bind = Desc<SgAdaTaskBody, SgAdaTaskSpec* SgAdaTaskBody::*, &SgAdaTaskBody::p_spec>;
685};
686template <> struct describe_field_t<SgAdaTaskBody,SgStatementPtrList,&SgAdaTaskBody::p_statements> {
687 using parent = SgAdaTaskBody;
688 using field_type = SgStatementPtrList;
689 static constexpr size_t position{1};
690 static constexpr char const * const name{"statements"};
691 static constexpr char const * const typestr{"SgStatementPtrList"};
692 static constexpr bool traverse{true};
693 static constexpr auto mbr_ptr{&SgAdaTaskBody::p_statements};
694 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
695 using bind = Desc<SgAdaTaskBody, SgStatementPtrList SgAdaTaskBody::*, &SgAdaTaskBody::p_statements>;
696};
697template <> struct describe_node_t<SgAdaTaskBody> {
698 using node = SgAdaTaskBody;
699 using base = SgScopeStatement;
700 static constexpr char const * const name{"AdaTaskBody"};
701 static constexpr unsigned long variant{20};
702 static constexpr bool concrete{true};
703 using subclasses_t = mp::List<>;
705};
706template <> struct node_from_variant_t<20> { using type = SgAdaTaskBody; };
707
708// Class: AdaTaskBodyDecl
709template <> struct describe_field_t<SgAdaTaskBodyDecl,SgName,&SgAdaTaskBodyDecl::p_name> {
711 using field_type = SgName;
712 static constexpr size_t position{0};
713 static constexpr char const * const name{"name"};
714 static constexpr char const * const typestr{"SgName"};
715 static constexpr bool traverse{false};
716 static constexpr auto mbr_ptr{&SgAdaTaskBodyDecl::p_name};
717 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
718 using bind = Desc<SgAdaTaskBodyDecl, SgName SgAdaTaskBodyDecl::*, &SgAdaTaskBodyDecl::p_name>;
719};
720template <> struct describe_field_t<SgAdaTaskBodyDecl,SgDeclarationStatement*,&SgAdaTaskBodyDecl::p_specificationDeclaration> {
723 static constexpr size_t position{1};
724 static constexpr char const * const name{"specificationDeclaration"};
725 static constexpr char const * const typestr{"SgDeclarationStatement*"};
726 static constexpr bool traverse{false};
727 static constexpr auto mbr_ptr{&SgAdaTaskBodyDecl::p_specificationDeclaration};
728 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
729 using bind = Desc<SgAdaTaskBodyDecl, SgDeclarationStatement* SgAdaTaskBodyDecl::*, &SgAdaTaskBodyDecl::p_specificationDeclaration>;
730};
731template <> struct describe_field_t<SgAdaTaskBodyDecl,SgAdaTaskBody*,&SgAdaTaskBodyDecl::p_definition> {
733 using field_type = SgAdaTaskBody*;
734 static constexpr size_t position{2};
735 static constexpr char const * const name{"definition"};
736 static constexpr char const * const typestr{"SgAdaTaskBody*"};
737 static constexpr bool traverse{true};
738 static constexpr auto mbr_ptr{&SgAdaTaskBodyDecl::p_definition};
739 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
740 using bind = Desc<SgAdaTaskBodyDecl, SgAdaTaskBody* SgAdaTaskBodyDecl::*, &SgAdaTaskBodyDecl::p_definition>;
741};
751template <> struct node_from_variant_t<21> { using type = SgAdaTaskBodyDecl; };
752
753// Class: AdaTaskSpec
754template <> struct describe_field_t<SgAdaTaskSpec,SgAdaTaskBody*,&SgAdaTaskSpec::p_body> {
755 using parent = SgAdaTaskSpec;
756 using field_type = SgAdaTaskBody*;
757 static constexpr size_t position{0};
758 static constexpr char const * const name{"body"};
759 static constexpr char const * const typestr{"SgAdaTaskBody*"};
760 static constexpr bool traverse{false};
761 static constexpr auto mbr_ptr{&SgAdaTaskSpec::p_body};
762 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
763 using bind = Desc<SgAdaTaskSpec, SgAdaTaskBody* SgAdaTaskSpec::*, &SgAdaTaskSpec::p_body>;
764};
765template <> struct describe_field_t<SgAdaTaskSpec,SgDeclarationStatementPtrList,&SgAdaTaskSpec::p_declarations> {
766 using parent = SgAdaTaskSpec;
767 using field_type = SgDeclarationStatementPtrList;
768 static constexpr size_t position{1};
769 static constexpr char const * const name{"declarations"};
770 static constexpr char const * const typestr{"SgDeclarationStatementPtrList"};
771 static constexpr bool traverse{true};
772 static constexpr auto mbr_ptr{&SgAdaTaskSpec::p_declarations};
773 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
774 using bind = Desc<SgAdaTaskSpec, SgDeclarationStatementPtrList SgAdaTaskSpec::*, &SgAdaTaskSpec::p_declarations>;
775};
776template <> struct describe_field_t<SgAdaTaskSpec,bool,&SgAdaTaskSpec::p_hasPrivate> {
777 using parent = SgAdaTaskSpec;
778 using field_type = bool;
779 static constexpr size_t position{2};
780 static constexpr char const * const name{"hasPrivate"};
781 static constexpr char const * const typestr{"bool"};
782 static constexpr bool traverse{false};
783 static constexpr auto mbr_ptr{&SgAdaTaskSpec::p_hasPrivate};
784 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
785 using bind = Desc<SgAdaTaskSpec, bool SgAdaTaskSpec::*, &SgAdaTaskSpec::p_hasPrivate>;
786};
787template <> struct describe_node_t<SgAdaTaskSpec> {
788 using node = SgAdaTaskSpec;
789 using base = SgScopeStatement;
790 static constexpr char const * const name{"AdaTaskSpec"};
791 static constexpr unsigned long variant{22};
792 static constexpr bool concrete{true};
793 using subclasses_t = mp::List<>;
795};
796template <> struct node_from_variant_t<22> { using type = SgAdaTaskSpec; };
797
798// Class: AdaTaskSpecDecl
799template <> struct describe_field_t<SgAdaTaskSpecDecl,SgName,&SgAdaTaskSpecDecl::p_name> {
801 using field_type = SgName;
802 static constexpr size_t position{0};
803 static constexpr char const * const name{"name"};
804 static constexpr char const * const typestr{"SgName"};
805 static constexpr bool traverse{false};
806 static constexpr auto mbr_ptr{&SgAdaTaskSpecDecl::p_name};
807 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
808 using bind = Desc<SgAdaTaskSpecDecl, SgName SgAdaTaskSpecDecl::*, &SgAdaTaskSpecDecl::p_name>;
809};
810template <> struct describe_field_t<SgAdaTaskSpecDecl,SgAdaTaskSpec*,&SgAdaTaskSpecDecl::p_definition> {
812 using field_type = SgAdaTaskSpec*;
813 static constexpr size_t position{1};
814 static constexpr char const * const name{"definition"};
815 static constexpr char const * const typestr{"SgAdaTaskSpec*"};
816 static constexpr bool traverse{true};
817 static constexpr auto mbr_ptr{&SgAdaTaskSpecDecl::p_definition};
818 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
819 using bind = Desc<SgAdaTaskSpecDecl, SgAdaTaskSpec* SgAdaTaskSpecDecl::*, &SgAdaTaskSpecDecl::p_definition>;
820};
821template <> struct describe_field_t<SgAdaTaskSpecDecl,SgAdaTaskType*,&SgAdaTaskSpecDecl::p_type> {
823 using field_type = SgAdaTaskType*;
824 static constexpr size_t position{2};
825 static constexpr char const * const name{"type"};
826 static constexpr char const * const typestr{"SgAdaTaskType*"};
827 static constexpr bool traverse{false};
828 static constexpr auto mbr_ptr{&SgAdaTaskSpecDecl::p_type};
829 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
830 using bind = Desc<SgAdaTaskSpecDecl, SgAdaTaskType* SgAdaTaskSpecDecl::*, &SgAdaTaskSpecDecl::p_type>;
831};
833 using node = SgAdaTaskSpecDecl;
835 static constexpr char const * const name{"AdaTaskSpecDecl"};
836 static constexpr unsigned long variant{23};
837 static constexpr bool concrete{true};
838 using subclasses_t = mp::List<>;
840};
841template <> struct node_from_variant_t<23> { using type = SgAdaTaskSpecDecl; };
842
843// Class: AdaTaskSymbol
844template <> struct describe_field_t<SgAdaTaskSymbol,SgDeclarationStatement*,&SgAdaTaskSymbol::p_declaration> {
845 using parent = SgAdaTaskSymbol;
847 static constexpr size_t position{0};
848 static constexpr char const * const name{"declaration"};
849 static constexpr char const * const typestr{"SgDeclarationStatement*"};
850 static constexpr bool traverse{true};
851 static constexpr auto mbr_ptr{&SgAdaTaskSymbol::p_declaration};
852 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
853 using bind = Desc<SgAdaTaskSymbol, SgDeclarationStatement* SgAdaTaskSymbol::*, &SgAdaTaskSymbol::p_declaration>;
854};
855template <> struct describe_node_t<SgAdaTaskSymbol> {
856 using node = SgAdaTaskSymbol;
857 using base = SgSymbol;
858 static constexpr char const * const name{"AdaTaskSymbol"};
859 static constexpr unsigned long variant{24};
860 static constexpr bool concrete{true};
861 using subclasses_t = mp::List<>;
863};
864template <> struct node_from_variant_t<24> { using type = SgAdaTaskSymbol; };
865
866// Class: AdaTaskRefExp
867template <> struct describe_field_t<SgAdaTaskRefExp,SgAdaTaskSymbol*,&SgAdaTaskRefExp::p_symbol> {
868 using parent = SgAdaTaskRefExp;
870 static constexpr size_t position{0};
871 static constexpr char const * const name{"symbol"};
872 static constexpr char const * const typestr{"SgAdaTaskSymbol*"};
873 static constexpr bool traverse{false};
874 static constexpr auto mbr_ptr{&SgAdaTaskRefExp::p_symbol};
875 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
876 using bind = Desc<SgAdaTaskRefExp, SgAdaTaskSymbol* SgAdaTaskRefExp::*, &SgAdaTaskRefExp::p_symbol>;
877};
878template <> struct describe_node_t<SgAdaTaskRefExp> {
879 using node = SgAdaTaskRefExp;
880 using base = SgExpression;
881 static constexpr char const * const name{"AdaTaskRefExp"};
882 static constexpr unsigned long variant{25};
883 static constexpr bool concrete{true};
884 using subclasses_t = mp::List<>;
886};
887template <> struct node_from_variant_t<25> { using type = SgAdaTaskRefExp; };
888
889// Class: AdaTaskType
890template <> struct describe_node_t<SgAdaTaskType> {
891 using node = SgAdaTaskType;
892 using base = SgNamedType;
893 static constexpr char const * const name{"AdaTaskType"};
894 static constexpr unsigned long variant{26};
895 static constexpr bool concrete{true};
896 using subclasses_t = mp::List<>;
897 using fields_t = mp::List<>;
898};
899template <> struct node_from_variant_t<26> { using type = SgAdaTaskType; };
900
901// Class: AdaTaskTypeDecl
902template <> struct describe_field_t<SgAdaTaskTypeDecl,SgName,&SgAdaTaskTypeDecl::p_name> {
904 using field_type = SgName;
905 static constexpr size_t position{0};
906 static constexpr char const * const name{"name"};
907 static constexpr char const * const typestr{"SgName"};
908 static constexpr bool traverse{false};
909 static constexpr auto mbr_ptr{&SgAdaTaskTypeDecl::p_name};
910 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
911 using bind = Desc<SgAdaTaskTypeDecl, SgName SgAdaTaskTypeDecl::*, &SgAdaTaskTypeDecl::p_name>;
912};
913template <> struct describe_field_t<SgAdaTaskTypeDecl,SgAdaTaskSpec*,&SgAdaTaskTypeDecl::p_definition> {
915 using field_type = SgAdaTaskSpec*;
916 static constexpr size_t position{1};
917 static constexpr char const * const name{"definition"};
918 static constexpr char const * const typestr{"SgAdaTaskSpec*"};
919 static constexpr bool traverse{true};
920 static constexpr auto mbr_ptr{&SgAdaTaskTypeDecl::p_definition};
921 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
922 using bind = Desc<SgAdaTaskTypeDecl, SgAdaTaskSpec* SgAdaTaskTypeDecl::*, &SgAdaTaskTypeDecl::p_definition>;
923};
924template <> struct describe_field_t<SgAdaTaskTypeDecl,SgAdaTaskType*,&SgAdaTaskTypeDecl::p_type> {
926 using field_type = SgAdaTaskType*;
927 static constexpr size_t position{2};
928 static constexpr char const * const name{"type"};
929 static constexpr char const * const typestr{"SgAdaTaskType*"};
930 static constexpr bool traverse{false};
931 static constexpr auto mbr_ptr{&SgAdaTaskTypeDecl::p_type};
932 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
933 using bind = Desc<SgAdaTaskTypeDecl, SgAdaTaskType* SgAdaTaskTypeDecl::*, &SgAdaTaskTypeDecl::p_type>;
934};
935template <> struct describe_field_t<SgAdaTaskTypeDecl,SgScopeStatement*,&SgAdaTaskTypeDecl::p_scope> {
938 static constexpr size_t position{3};
939 static constexpr char const * const name{"scope"};
940 static constexpr char const * const typestr{"SgScopeStatement*"};
941 static constexpr bool traverse{false};
942 static constexpr auto mbr_ptr{&SgAdaTaskTypeDecl::p_scope};
943 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
944 using bind = Desc<SgAdaTaskTypeDecl, SgScopeStatement* SgAdaTaskTypeDecl::*, &SgAdaTaskTypeDecl::p_scope>;
945};
955template <> struct node_from_variant_t<27> { using type = SgAdaTaskTypeDecl; };
956
957// Class: AdaTypeConstraint
961 static constexpr char const * const name{"AdaTypeConstraint"};
962 static constexpr unsigned long variant{28};
963 static constexpr bool concrete{false};
965 using fields_t = mp::List<>;
966};
967template <> struct node_from_variant_t<28> { using type = SgAdaTypeConstraint; };
968
969// Class: AddOp
970template <> struct describe_node_t<SgAddOp> {
971 using node = SgAddOp;
972 using base = SgBinaryOp;
973 static constexpr char const * const name{"AddOp"};
974 static constexpr unsigned long variant{29};
975 static constexpr bool concrete{true};
976 using subclasses_t = mp::List<>;
977 using fields_t = mp::List<>;
978};
979template <> struct node_from_variant_t<29> { using type = SgAddOp; };
980
981// Class: AddressOfOp
982template <> struct describe_field_t<SgAddressOfOp,SgExpression*,&SgAddressOfOp::p_originalExpressionTree> {
983 using parent = SgAddressOfOp;
984 using field_type = SgExpression*;
985 static constexpr size_t position{0};
986 static constexpr char const * const name{"originalExpressionTree"};
987 static constexpr char const * const typestr{"SgExpression*"};
988 static constexpr bool traverse{false};
989 static constexpr auto mbr_ptr{&SgAddressOfOp::p_originalExpressionTree};
990 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
991 using bind = Desc<SgAddressOfOp, SgExpression* SgAddressOfOp::*, &SgAddressOfOp::p_originalExpressionTree>;
992};
993template <> struct describe_node_t<SgAddressOfOp> {
994 using node = SgAddressOfOp;
995 using base = SgUnaryOp;
996 static constexpr char const * const name{"AddressOfOp"};
997 static constexpr unsigned long variant{30};
998 static constexpr bool concrete{true};
999 using subclasses_t = mp::List<>;
1001};
1002template <> struct node_from_variant_t<30> { using type = SgAddressOfOp; };
1003
1004// Class: AggregateInitializer
1007 using field_type = SgExprListExp*;
1008 static constexpr size_t position{0};
1009 static constexpr char const * const name{"initializers"};
1010 static constexpr char const * const typestr{"SgExprListExp*"};
1011 static constexpr bool traverse{true};
1012 static constexpr auto mbr_ptr{&SgAggregateInitializer::p_initializers};
1013 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1014 using bind = Desc<SgAggregateInitializer, SgExprListExp* SgAggregateInitializer::*, &SgAggregateInitializer::p_initializers>;
1015};
1016template <> struct describe_field_t<SgAggregateInitializer,SgType*,&SgAggregateInitializer::p_expression_type> {
1018 using field_type = SgType*;
1019 static constexpr size_t position{1};
1020 static constexpr char const * const name{"expression_type"};
1021 static constexpr char const * const typestr{"SgType*"};
1022 static constexpr bool traverse{false};
1023 static constexpr auto mbr_ptr{&SgAggregateInitializer::p_expression_type};
1024 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1025 using bind = Desc<SgAggregateInitializer, SgType* SgAggregateInitializer::*, &SgAggregateInitializer::p_expression_type>;
1026};
1027template <> struct describe_field_t<SgAggregateInitializer,bool,&SgAggregateInitializer::p_need_explicit_braces> {
1029 using field_type = bool;
1030 static constexpr size_t position{2};
1031 static constexpr char const * const name{"need_explicit_braces"};
1032 static constexpr char const * const typestr{"bool"};
1033 static constexpr bool traverse{false};
1034 static constexpr auto mbr_ptr{&SgAggregateInitializer::p_need_explicit_braces};
1035 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1036 using bind = Desc<SgAggregateInitializer, bool SgAggregateInitializer::*, &SgAggregateInitializer::p_need_explicit_braces>;
1037};
1038template <> struct describe_field_t<SgAggregateInitializer,bool,&SgAggregateInitializer::p_uses_compound_literal> {
1040 using field_type = bool;
1041 static constexpr size_t position{3};
1042 static constexpr char const * const name{"uses_compound_literal"};
1043 static constexpr char const * const typestr{"bool"};
1044 static constexpr bool traverse{false};
1045 static constexpr auto mbr_ptr{&SgAggregateInitializer::p_uses_compound_literal};
1046 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1047 using bind = Desc<SgAggregateInitializer, bool SgAggregateInitializer::*, &SgAggregateInitializer::p_uses_compound_literal>;
1048};
1049template <> struct describe_field_t<SgAggregateInitializer,bool,&SgAggregateInitializer::p_requiresGlobalNameQualificationOnType> {
1051 using field_type = bool;
1052 static constexpr size_t position{4};
1053 static constexpr char const * const name{"requiresGlobalNameQualificationOnType"};
1054 static constexpr char const * const typestr{"bool"};
1055 static constexpr bool traverse{false};
1056 static constexpr auto mbr_ptr{&SgAggregateInitializer::p_requiresGlobalNameQualificationOnType};
1057 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1058 using bind = Desc<SgAggregateInitializer, bool SgAggregateInitializer::*, &SgAggregateInitializer::p_requiresGlobalNameQualificationOnType>;
1059};
1060template <> struct describe_field_t<SgAggregateInitializer,int,&SgAggregateInitializer::p_name_qualification_length_for_type> {
1062 using field_type = int;
1063 static constexpr size_t position{5};
1064 static constexpr char const * const name{"name_qualification_length_for_type"};
1065 static constexpr char const * const typestr{"int"};
1066 static constexpr bool traverse{false};
1067 static constexpr auto mbr_ptr{&SgAggregateInitializer::p_name_qualification_length_for_type};
1068 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1069 using bind = Desc<SgAggregateInitializer, int SgAggregateInitializer::*, &SgAggregateInitializer::p_name_qualification_length_for_type>;
1070};
1071template <> struct describe_field_t<SgAggregateInitializer,bool,&SgAggregateInitializer::p_type_elaboration_required_for_type> {
1073 using field_type = bool;
1074 static constexpr size_t position{6};
1075 static constexpr char const * const name{"type_elaboration_required_for_type"};
1076 static constexpr char const * const typestr{"bool"};
1077 static constexpr bool traverse{false};
1078 static constexpr auto mbr_ptr{&SgAggregateInitializer::p_type_elaboration_required_for_type};
1079 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1080 using bind = Desc<SgAggregateInitializer, bool SgAggregateInitializer::*, &SgAggregateInitializer::p_type_elaboration_required_for_type>;
1081};
1082template <> struct describe_field_t<SgAggregateInitializer,bool,&SgAggregateInitializer::p_global_qualification_required_for_type> {
1084 using field_type = bool;
1085 static constexpr size_t position{7};
1086 static constexpr char const * const name{"global_qualification_required_for_type"};
1087 static constexpr char const * const typestr{"bool"};
1088 static constexpr bool traverse{false};
1089 static constexpr auto mbr_ptr{&SgAggregateInitializer::p_global_qualification_required_for_type};
1090 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1091 using bind = Desc<SgAggregateInitializer, bool SgAggregateInitializer::*, &SgAggregateInitializer::p_global_qualification_required_for_type>;
1092};
1093template <> struct describe_field_t<SgAggregateInitializer,SgExpression*,&SgAggregateInitializer::p_originalExpressionTree> {
1095 using field_type = SgExpression*;
1096 static constexpr size_t position{8};
1097 static constexpr char const * const name{"originalExpressionTree"};
1098 static constexpr char const * const typestr{"SgExpression*"};
1099 static constexpr bool traverse{false};
1100 static constexpr auto mbr_ptr{&SgAggregateInitializer::p_originalExpressionTree};
1101 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1102 using bind = Desc<SgAggregateInitializer, SgExpression* SgAggregateInitializer::*, &SgAggregateInitializer::p_originalExpressionTree>;
1103};
1113template <> struct node_from_variant_t<31> { using type = SgAggregateInitializer; };
1114
1115// Class: AliasSymbol
1116template <> struct describe_field_t<SgAliasSymbol,SgSymbol*,&SgAliasSymbol::p_alias> {
1117 using parent = SgAliasSymbol;
1118 using field_type = SgSymbol*;
1119 static constexpr size_t position{0};
1120 static constexpr char const * const name{"alias"};
1121 static constexpr char const * const typestr{"SgSymbol*"};
1122 static constexpr bool traverse{true};
1123 static constexpr auto mbr_ptr{&SgAliasSymbol::p_alias};
1124 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1125 using bind = Desc<SgAliasSymbol, SgSymbol* SgAliasSymbol::*, &SgAliasSymbol::p_alias>;
1126};
1127template <> struct describe_field_t<SgAliasSymbol,bool,&SgAliasSymbol::p_isRenamed> {
1128 using parent = SgAliasSymbol;
1129 using field_type = bool;
1130 static constexpr size_t position{1};
1131 static constexpr char const * const name{"isRenamed"};
1132 static constexpr char const * const typestr{"bool"};
1133 static constexpr bool traverse{false};
1134 static constexpr auto mbr_ptr{&SgAliasSymbol::p_isRenamed};
1135 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1136 using bind = Desc<SgAliasSymbol, bool SgAliasSymbol::*, &SgAliasSymbol::p_isRenamed>;
1137};
1138template <> struct describe_field_t<SgAliasSymbol,SgName,&SgAliasSymbol::p_new_name> {
1139 using parent = SgAliasSymbol;
1140 using field_type = SgName;
1141 static constexpr size_t position{2};
1142 static constexpr char const * const name{"new_name"};
1143 static constexpr char const * const typestr{"SgName"};
1144 static constexpr bool traverse{false};
1145 static constexpr auto mbr_ptr{&SgAliasSymbol::p_new_name};
1146 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1147 using bind = Desc<SgAliasSymbol, SgName SgAliasSymbol::*, &SgAliasSymbol::p_new_name>;
1148};
1149template <> struct describe_field_t<SgAliasSymbol,SgNodePtrList,&SgAliasSymbol::p_causal_nodes> {
1150 using parent = SgAliasSymbol;
1151 using field_type = SgNodePtrList;
1152 static constexpr size_t position{3};
1153 static constexpr char const * const name{"causal_nodes"};
1154 static constexpr char const * const typestr{"SgNodePtrList"};
1155 static constexpr bool traverse{false};
1156 static constexpr auto mbr_ptr{&SgAliasSymbol::p_causal_nodes};
1157 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1158 using bind = Desc<SgAliasSymbol, SgNodePtrList SgAliasSymbol::*, &SgAliasSymbol::p_causal_nodes>;
1159};
1160template <> struct describe_node_t<SgAliasSymbol> {
1161 using node = SgAliasSymbol;
1162 using base = SgSymbol;
1163 static constexpr char const * const name{"AliasSymbol"};
1164 static constexpr unsigned long variant{32};
1165 static constexpr bool concrete{true};
1166 using subclasses_t = mp::List<>;
1168};
1169template <> struct node_from_variant_t<32> { using type = SgAliasSymbol; };
1170
1171// Class: AllocateStatement
1172template <> struct describe_field_t<SgAllocateStatement,SgExprListExp*,&SgAllocateStatement::p_expr_list> {
1174 using field_type = SgExprListExp*;
1175 static constexpr size_t position{0};
1176 static constexpr char const * const name{"expr_list"};
1177 static constexpr char const * const typestr{"SgExprListExp*"};
1178 static constexpr bool traverse{true};
1179 static constexpr auto mbr_ptr{&SgAllocateStatement::p_expr_list};
1180 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1181 using bind = Desc<SgAllocateStatement, SgExprListExp* SgAllocateStatement::*, &SgAllocateStatement::p_expr_list>;
1182};
1183template <> struct describe_field_t<SgAllocateStatement,SgExpression*,&SgAllocateStatement::p_stat_expression> {
1185 using field_type = SgExpression*;
1186 static constexpr size_t position{1};
1187 static constexpr char const * const name{"stat_expression"};
1188 static constexpr char const * const typestr{"SgExpression*"};
1189 static constexpr bool traverse{true};
1190 static constexpr auto mbr_ptr{&SgAllocateStatement::p_stat_expression};
1191 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1192 using bind = Desc<SgAllocateStatement, SgExpression* SgAllocateStatement::*, &SgAllocateStatement::p_stat_expression>;
1193};
1194template <> struct describe_field_t<SgAllocateStatement,SgExpression*,&SgAllocateStatement::p_errmsg_expression> {
1196 using field_type = SgExpression*;
1197 static constexpr size_t position{2};
1198 static constexpr char const * const name{"errmsg_expression"};
1199 static constexpr char const * const typestr{"SgExpression*"};
1200 static constexpr bool traverse{true};
1201 static constexpr auto mbr_ptr{&SgAllocateStatement::p_errmsg_expression};
1202 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1203 using bind = Desc<SgAllocateStatement, SgExpression* SgAllocateStatement::*, &SgAllocateStatement::p_errmsg_expression>;
1204};
1205template <> struct describe_field_t<SgAllocateStatement,SgExpression*,&SgAllocateStatement::p_source_expression> {
1207 using field_type = SgExpression*;
1208 static constexpr size_t position{3};
1209 static constexpr char const * const name{"source_expression"};
1210 static constexpr char const * const typestr{"SgExpression*"};
1211 static constexpr bool traverse{true};
1212 static constexpr auto mbr_ptr{&SgAllocateStatement::p_source_expression};
1213 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1214 using bind = Desc<SgAllocateStatement, SgExpression* SgAllocateStatement::*, &SgAllocateStatement::p_source_expression>;
1215};
1225template <> struct node_from_variant_t<33> { using type = SgAllocateStatement; };
1226
1227// Class: AndAssignOp
1228template <> struct describe_node_t<SgAndAssignOp> {
1229 using node = SgAndAssignOp;
1230 using base = SgCompoundAssignOp;
1231 static constexpr char const * const name{"AndAssignOp"};
1232 static constexpr unsigned long variant{34};
1233 static constexpr bool concrete{true};
1234 using subclasses_t = mp::List<>;
1235 using fields_t = mp::List<>;
1236};
1237template <> struct node_from_variant_t<34> { using type = SgAndAssignOp; };
1238
1239// Class: AndOp
1240template <> struct describe_node_t<SgAndOp> {
1241 using node = SgAndOp;
1242 using base = SgBinaryOp;
1243 static constexpr char const * const name{"AndOp"};
1244 static constexpr unsigned long variant{35};
1245 static constexpr bool concrete{true};
1246 using subclasses_t = mp::List<>;
1247 using fields_t = mp::List<>;
1248};
1249template <> struct node_from_variant_t<35> { using type = SgAndOp; };
1250
1251// Class: ArithmeticIfStatement
1252template <> struct describe_field_t<SgArithmeticIfStatement,SgExpression*,&SgArithmeticIfStatement::p_conditional> {
1254 using field_type = SgExpression*;
1255 static constexpr size_t position{0};
1256 static constexpr char const * const name{"conditional"};
1257 static constexpr char const * const typestr{"SgExpression*"};
1258 static constexpr bool traverse{true};
1259 static constexpr auto mbr_ptr{&SgArithmeticIfStatement::p_conditional};
1260 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1261 using bind = Desc<SgArithmeticIfStatement, SgExpression* SgArithmeticIfStatement::*, &SgArithmeticIfStatement::p_conditional>;
1262};
1263template <> struct describe_field_t<SgArithmeticIfStatement,SgLabelRefExp*,&SgArithmeticIfStatement::p_less_label> {
1265 using field_type = SgLabelRefExp*;
1266 static constexpr size_t position{1};
1267 static constexpr char const * const name{"less_label"};
1268 static constexpr char const * const typestr{"SgLabelRefExp*"};
1269 static constexpr bool traverse{false};
1270 static constexpr auto mbr_ptr{&SgArithmeticIfStatement::p_less_label};
1271 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1272 using bind = Desc<SgArithmeticIfStatement, SgLabelRefExp* SgArithmeticIfStatement::*, &SgArithmeticIfStatement::p_less_label>;
1273};
1274template <> struct describe_field_t<SgArithmeticIfStatement,SgLabelRefExp*,&SgArithmeticIfStatement::p_equal_label> {
1276 using field_type = SgLabelRefExp*;
1277 static constexpr size_t position{2};
1278 static constexpr char const * const name{"equal_label"};
1279 static constexpr char const * const typestr{"SgLabelRefExp*"};
1280 static constexpr bool traverse{false};
1281 static constexpr auto mbr_ptr{&SgArithmeticIfStatement::p_equal_label};
1282 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1283 using bind = Desc<SgArithmeticIfStatement, SgLabelRefExp* SgArithmeticIfStatement::*, &SgArithmeticIfStatement::p_equal_label>;
1284};
1285template <> struct describe_field_t<SgArithmeticIfStatement,SgLabelRefExp*,&SgArithmeticIfStatement::p_greater_label> {
1287 using field_type = SgLabelRefExp*;
1288 static constexpr size_t position{3};
1289 static constexpr char const * const name{"greater_label"};
1290 static constexpr char const * const typestr{"SgLabelRefExp*"};
1291 static constexpr bool traverse{false};
1292 static constexpr auto mbr_ptr{&SgArithmeticIfStatement::p_greater_label};
1293 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1294 using bind = Desc<SgArithmeticIfStatement, SgLabelRefExp* SgArithmeticIfStatement::*, &SgArithmeticIfStatement::p_greater_label>;
1295};
1305template <> struct node_from_variant_t<36> { using type = SgArithmeticIfStatement; };
1306
1307// Class: ArrayType
1308template <> struct describe_field_t<SgArrayType,SgType*,&SgArrayType::p_base_type> {
1309 using parent = SgArrayType;
1310 using field_type = SgType*;
1311 static constexpr size_t position{0};
1312 static constexpr char const * const name{"base_type"};
1313 static constexpr char const * const typestr{"SgType*"};
1314 static constexpr bool traverse{false};
1315 static constexpr auto mbr_ptr{&SgArrayType::p_base_type};
1316 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1317 using bind = Desc<SgArrayType, SgType* SgArrayType::*, &SgArrayType::p_base_type>;
1318};
1319template <> struct describe_field_t<SgArrayType,SgExpression*,&SgArrayType::p_index> {
1320 using parent = SgArrayType;
1321 using field_type = SgExpression*;
1322 static constexpr size_t position{1};
1323 static constexpr char const * const name{"index"};
1324 static constexpr char const * const typestr{"SgExpression*"};
1325 static constexpr bool traverse{true};
1326 static constexpr auto mbr_ptr{&SgArrayType::p_index};
1327 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1328 using bind = Desc<SgArrayType, SgExpression* SgArrayType::*, &SgArrayType::p_index>;
1329};
1330template <> struct describe_field_t<SgArrayType,SgExprListExp*,&SgArrayType::p_dim_info> {
1331 using parent = SgArrayType;
1332 using field_type = SgExprListExp*;
1333 static constexpr size_t position{2};
1334 static constexpr char const * const name{"dim_info"};
1335 static constexpr char const * const typestr{"SgExprListExp*"};
1336 static constexpr bool traverse{true};
1337 static constexpr auto mbr_ptr{&SgArrayType::p_dim_info};
1338 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1339 using bind = Desc<SgArrayType, SgExprListExp* SgArrayType::*, &SgArrayType::p_dim_info>;
1340};
1341template <> struct describe_field_t<SgArrayType,int,&SgArrayType::p_rank> {
1342 using parent = SgArrayType;
1343 using field_type = int;
1344 static constexpr size_t position{3};
1345 static constexpr char const * const name{"rank"};
1346 static constexpr char const * const typestr{"int"};
1347 static constexpr bool traverse{false};
1348 static constexpr auto mbr_ptr{&SgArrayType::p_rank};
1349 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1350 using bind = Desc<SgArrayType, int SgArrayType::*, &SgArrayType::p_rank>;
1351};
1352template <> struct describe_field_t<SgArrayType,int,&SgArrayType::p_number_of_elements> {
1353 using parent = SgArrayType;
1354 using field_type = int;
1355 static constexpr size_t position{4};
1356 static constexpr char const * const name{"number_of_elements"};
1357 static constexpr char const * const typestr{"int"};
1358 static constexpr bool traverse{false};
1359 static constexpr auto mbr_ptr{&SgArrayType::p_number_of_elements};
1360 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1361 using bind = Desc<SgArrayType, int SgArrayType::*, &SgArrayType::p_number_of_elements>;
1362};
1363template <> struct describe_field_t<SgArrayType,bool,&SgArrayType::p_is_variable_length_array> {
1364 using parent = SgArrayType;
1365 using field_type = bool;
1366 static constexpr size_t position{5};
1367 static constexpr char const * const name{"is_variable_length_array"};
1368 static constexpr char const * const typestr{"bool"};
1369 static constexpr bool traverse{false};
1370 static constexpr auto mbr_ptr{&SgArrayType::p_is_variable_length_array};
1371 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1372 using bind = Desc<SgArrayType, bool SgArrayType::*, &SgArrayType::p_is_variable_length_array>;
1373};
1383template <> struct node_from_variant_t<37> { using type = SgArrayType; };
1384
1385// Class: ArrowExp
1386template <> struct describe_node_t<SgArrowExp> {
1387 using node = SgArrowExp;
1388 using base = SgBinaryOp;
1389 static constexpr char const * const name{"ArrowExp"};
1390 static constexpr unsigned long variant{38};
1391 static constexpr bool concrete{true};
1392 using subclasses_t = mp::List<>;
1393 using fields_t = mp::List<>;
1394};
1395template <> struct node_from_variant_t<38> { using type = SgArrowExp; };
1396
1397// Class: ArrowStarOp
1398template <> struct describe_node_t<SgArrowStarOp> {
1399 using node = SgArrowStarOp;
1400 using base = SgBinaryOp;
1401 static constexpr char const * const name{"ArrowStarOp"};
1402 static constexpr unsigned long variant{39};
1403 static constexpr bool concrete{true};
1404 using subclasses_t = mp::List<>;
1405 using fields_t = mp::List<>;
1406};
1407template <> struct node_from_variant_t<39> { using type = SgArrowStarOp; };
1408
1409// Class: AsmBasicString
1410template <> struct describe_field_t<SgAsmBasicString,std::string,&SgAsmBasicString::p_string> {
1411 using parent = SgAsmBasicString;
1412 using field_type = std::string;
1413 static constexpr size_t position{0};
1414 static constexpr char const * const name{"string"};
1415 static constexpr char const * const typestr{"std::string"};
1416 static constexpr bool traverse{false};
1417 static constexpr auto mbr_ptr{&SgAsmBasicString::p_string};
1418 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1419 using bind = Desc<SgAsmBasicString, std::string SgAsmBasicString::*, &SgAsmBasicString::p_string>;
1420};
1422 using node = SgAsmBasicString;
1423 using base = SgAsmGenericString;
1424 static constexpr char const * const name{"AsmBasicString"};
1425 static constexpr unsigned long variant{46};
1426 static constexpr bool concrete{true};
1427 using subclasses_t = mp::List<>;
1429};
1430template <> struct node_from_variant_t<46> { using type = SgAsmBasicString; };
1431
1432// Class: AsmBinaryAdd
1433template <> struct describe_node_t<SgAsmBinaryAdd> {
1434 using node = SgAsmBinaryAdd;
1436 static constexpr char const * const name{"AsmBinaryAdd"};
1437 static constexpr unsigned long variant{47};
1438 static constexpr bool concrete{true};
1439 using subclasses_t = mp::List<>;
1440 using fields_t = mp::List<>;
1441};
1442template <> struct node_from_variant_t<47> { using type = SgAsmBinaryAdd; };
1443
1444// Class: AsmBinaryAsr
1445template <> struct describe_node_t<SgAsmBinaryAsr> {
1446 using node = SgAsmBinaryAsr;
1448 static constexpr char const * const name{"AsmBinaryAsr"};
1449 static constexpr unsigned long variant{50};
1450 static constexpr bool concrete{true};
1451 using subclasses_t = mp::List<>;
1452 using fields_t = mp::List<>;
1453};
1454template <> struct node_from_variant_t<50> { using type = SgAsmBinaryAsr; };
1455
1456// Class: AsmBinaryDivide
1458 using node = SgAsmBinaryDivide;
1460 static constexpr char const * const name{"AsmBinaryDivide"};
1461 static constexpr unsigned long variant{51};
1462 static constexpr bool concrete{true};
1463 using subclasses_t = mp::List<>;
1464 using fields_t = mp::List<>;
1465};
1466template <> struct node_from_variant_t<51> { using type = SgAsmBinaryDivide; };
1467
1468// Class: AsmBinaryExpression
1469template <> struct describe_field_t<SgAsmBinaryExpression,SgAsmExpression*,&SgAsmBinaryExpression::p_lhs> {
1471 using field_type = SgAsmExpression*;
1472 static constexpr size_t position{0};
1473 static constexpr char const * const name{"lhs"};
1474 static constexpr char const * const typestr{"SgAsmExpression*"};
1475 static constexpr bool traverse{true};
1476 static constexpr auto mbr_ptr{&SgAsmBinaryExpression::p_lhs};
1477 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1478 using bind = Desc<SgAsmBinaryExpression, SgAsmExpression* SgAsmBinaryExpression::*, &SgAsmBinaryExpression::p_lhs>;
1479};
1480template <> struct describe_field_t<SgAsmBinaryExpression,SgAsmExpression*,&SgAsmBinaryExpression::p_rhs> {
1482 using field_type = SgAsmExpression*;
1483 static constexpr size_t position{1};
1484 static constexpr char const * const name{"rhs"};
1485 static constexpr char const * const typestr{"SgAsmExpression*"};
1486 static constexpr bool traverse{true};
1487 static constexpr auto mbr_ptr{&SgAsmBinaryExpression::p_rhs};
1488 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1489 using bind = Desc<SgAsmBinaryExpression, SgAsmExpression* SgAsmBinaryExpression::*, &SgAsmBinaryExpression::p_rhs>;
1490};
1500template <> struct node_from_variant_t<52> { using type = SgAsmBinaryExpression; };
1501
1502// Class: AsmBinaryLsl
1503template <> struct describe_node_t<SgAsmBinaryLsl> {
1504 using node = SgAsmBinaryLsl;
1506 static constexpr char const * const name{"AsmBinaryLsl"};
1507 static constexpr unsigned long variant{53};
1508 static constexpr bool concrete{true};
1509 using subclasses_t = mp::List<>;
1510 using fields_t = mp::List<>;
1511};
1512template <> struct node_from_variant_t<53> { using type = SgAsmBinaryLsl; };
1513
1514// Class: AsmBinaryLsr
1515template <> struct describe_node_t<SgAsmBinaryLsr> {
1516 using node = SgAsmBinaryLsr;
1518 static constexpr char const * const name{"AsmBinaryLsr"};
1519 static constexpr unsigned long variant{54};
1520 static constexpr bool concrete{true};
1521 using subclasses_t = mp::List<>;
1522 using fields_t = mp::List<>;
1523};
1524template <> struct node_from_variant_t<54> { using type = SgAsmBinaryLsr; };
1525
1526// Class: AsmBinaryMod
1527template <> struct describe_node_t<SgAsmBinaryMod> {
1528 using node = SgAsmBinaryMod;
1530 static constexpr char const * const name{"AsmBinaryMod"};
1531 static constexpr unsigned long variant{55};
1532 static constexpr bool concrete{true};
1533 using subclasses_t = mp::List<>;
1534 using fields_t = mp::List<>;
1535};
1536template <> struct node_from_variant_t<55> { using type = SgAsmBinaryMod; };
1537
1538// Class: AsmBinaryMsl
1539template <> struct describe_node_t<SgAsmBinaryMsl> {
1540 using node = SgAsmBinaryMsl;
1542 static constexpr char const * const name{"AsmBinaryMsl"};
1543 static constexpr unsigned long variant{56};
1544 static constexpr bool concrete{true};
1545 using subclasses_t = mp::List<>;
1546 using fields_t = mp::List<>;
1547};
1548template <> struct node_from_variant_t<56> { using type = SgAsmBinaryMsl; };
1549
1550// Class: AsmBinaryMultiply
1552 using node = SgAsmBinaryMultiply;
1554 static constexpr char const * const name{"AsmBinaryMultiply"};
1555 static constexpr unsigned long variant{57};
1556 static constexpr bool concrete{true};
1557 using subclasses_t = mp::List<>;
1558 using fields_t = mp::List<>;
1559};
1560template <> struct node_from_variant_t<57> { using type = SgAsmBinaryMultiply; };
1561
1562// Class: AsmBinaryRor
1563template <> struct describe_node_t<SgAsmBinaryRor> {
1564 using node = SgAsmBinaryRor;
1566 static constexpr char const * const name{"AsmBinaryRor"};
1567 static constexpr unsigned long variant{58};
1568 static constexpr bool concrete{true};
1569 using subclasses_t = mp::List<>;
1570 using fields_t = mp::List<>;
1571};
1572template <> struct node_from_variant_t<58> { using type = SgAsmBinaryRor; };
1573
1574// Class: AsmBinarySubtract
1576 using node = SgAsmBinarySubtract;
1578 static constexpr char const * const name{"AsmBinarySubtract"};
1579 static constexpr unsigned long variant{59};
1580 static constexpr bool concrete{true};
1581 using subclasses_t = mp::List<>;
1582 using fields_t = mp::List<>;
1583};
1584template <> struct node_from_variant_t<59> { using type = SgAsmBinarySubtract; };
1585
1586// Class: AsmBlock
1587template <> struct describe_field_t<SgAsmBlock,Rose::BinaryAnalysis::Address,&SgAsmBlock::p_id> {
1588 using parent = SgAsmBlock;
1589 using field_type = Rose::BinaryAnalysis::Address;
1590 static constexpr size_t position{0};
1591 static constexpr char const * const name{"id"};
1592 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
1593 static constexpr bool traverse{false};
1594 static constexpr auto mbr_ptr{&SgAsmBlock::p_id};
1595 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1596 using bind = Desc<SgAsmBlock, Rose::BinaryAnalysis::Address SgAsmBlock::*, &SgAsmBlock::p_id>;
1597};
1598template <> struct describe_field_t<SgAsmBlock,unsigned,&SgAsmBlock::p_reason> {
1599 using parent = SgAsmBlock;
1600 using field_type = unsigned;
1601 static constexpr size_t position{1};
1602 static constexpr char const * const name{"reason"};
1603 static constexpr char const * const typestr{"unsigned"};
1604 static constexpr bool traverse{false};
1605 static constexpr auto mbr_ptr{&SgAsmBlock::p_reason};
1606 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1607 using bind = Desc<SgAsmBlock, unsigned SgAsmBlock::*, &SgAsmBlock::p_reason>;
1608};
1609template <> struct describe_field_t<SgAsmBlock,SgAsmStatementPtrList,&SgAsmBlock::p_statementList> {
1610 using parent = SgAsmBlock;
1611 using field_type = SgAsmStatementPtrList;
1612 static constexpr size_t position{2};
1613 static constexpr char const * const name{"statementList"};
1614 static constexpr char const * const typestr{"SgAsmStatementPtrList"};
1615 static constexpr bool traverse{true};
1616 static constexpr auto mbr_ptr{&SgAsmBlock::p_statementList};
1617 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1618 using bind = Desc<SgAsmBlock, SgAsmStatementPtrList SgAsmBlock::*, &SgAsmBlock::p_statementList>;
1619};
1620template <> struct describe_field_t<SgAsmBlock,SgAsmIntegerValuePtrList,&SgAsmBlock::p_successors> {
1621 using parent = SgAsmBlock;
1622 using field_type = SgAsmIntegerValuePtrList;
1623 static constexpr size_t position{3};
1624 static constexpr char const * const name{"successors"};
1625 static constexpr char const * const typestr{"SgAsmIntegerValuePtrList"};
1626 static constexpr bool traverse{false};
1627 static constexpr auto mbr_ptr{&SgAsmBlock::p_successors};
1628 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1629 using bind = Desc<SgAsmBlock, SgAsmIntegerValuePtrList SgAsmBlock::*, &SgAsmBlock::p_successors>;
1630};
1631template <> struct describe_field_t<SgAsmBlock,bool,&SgAsmBlock::p_successorsComplete> {
1632 using parent = SgAsmBlock;
1633 using field_type = bool;
1634 static constexpr size_t position{4};
1635 static constexpr char const * const name{"successorsComplete"};
1636 static constexpr char const * const typestr{"bool"};
1637 static constexpr bool traverse{false};
1638 static constexpr auto mbr_ptr{&SgAsmBlock::p_successorsComplete};
1639 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1640 using bind = Desc<SgAsmBlock, bool SgAsmBlock::*, &SgAsmBlock::p_successorsComplete>;
1641};
1642template <> struct describe_field_t<SgAsmBlock,SgAsmBlock*,&SgAsmBlock::p_immediateDominator> {
1643 using parent = SgAsmBlock;
1644 using field_type = SgAsmBlock*;
1645 static constexpr size_t position{5};
1646 static constexpr char const * const name{"immediateDominator"};
1647 static constexpr char const * const typestr{"SgAsmBlock*"};
1648 static constexpr bool traverse{false};
1649 static constexpr auto mbr_ptr{&SgAsmBlock::p_immediateDominator};
1650 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1651 using bind = Desc<SgAsmBlock, SgAsmBlock* SgAsmBlock::*, &SgAsmBlock::p_immediateDominator>;
1652};
1653template <> struct describe_field_t<SgAsmBlock,size_t,&SgAsmBlock::p_cachedVertex> {
1654 using parent = SgAsmBlock;
1655 using field_type = size_t;
1656 static constexpr size_t position{6};
1657 static constexpr char const * const name{"cachedVertex"};
1658 static constexpr char const * const typestr{"size_t"};
1659 static constexpr bool traverse{false};
1660 static constexpr auto mbr_ptr{&SgAsmBlock::p_cachedVertex};
1661 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1662 using bind = Desc<SgAsmBlock, size_t SgAsmBlock::*, &SgAsmBlock::p_cachedVertex>;
1663};
1664template <> struct describe_field_t<SgAsmBlock,double,&SgAsmBlock::p_codeLikelihood> {
1665 using parent = SgAsmBlock;
1666 using field_type = double;
1667 static constexpr size_t position{7};
1668 static constexpr char const * const name{"codeLikelihood"};
1669 static constexpr char const * const typestr{"double"};
1670 static constexpr bool traverse{false};
1671 static constexpr auto mbr_ptr{&SgAsmBlock::p_codeLikelihood};
1672 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1673 using bind = Desc<SgAsmBlock, double SgAsmBlock::*, &SgAsmBlock::p_codeLikelihood>;
1674};
1675template <> struct describe_field_t<SgAsmBlock,int64_t,&SgAsmBlock::p_stackDeltaOut> {
1676 using parent = SgAsmBlock;
1677 using field_type = int64_t;
1678 static constexpr size_t position{8};
1679 static constexpr char const * const name{"stackDeltaOut"};
1680 static constexpr char const * const typestr{"int64_t"};
1681 static constexpr bool traverse{false};
1682 static constexpr auto mbr_ptr{&SgAsmBlock::p_stackDeltaOut};
1683 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1684 using bind = Desc<SgAsmBlock, int64_t SgAsmBlock::*, &SgAsmBlock::p_stackDeltaOut>;
1685};
1695template <> struct node_from_variant_t<62> { using type = SgAsmBlock; };
1696
1697// Class: AsmCoffStrtab
1699 using node = SgAsmCoffStrtab;
1700 using base = SgAsmGenericStrtab;
1701 static constexpr char const * const name{"AsmCoffStrtab"};
1702 static constexpr unsigned long variant{63};
1703 static constexpr bool concrete{true};
1704 using subclasses_t = mp::List<>;
1705 using fields_t = mp::List<>;
1706};
1707template <> struct node_from_variant_t<63> { using type = SgAsmCoffStrtab; };
1708
1709// Class: AsmCoffSymbol
1710template <> struct describe_field_t<SgAsmCoffSymbol,std::string,&SgAsmCoffSymbol::p_st_name> {
1711 using parent = SgAsmCoffSymbol;
1712 using field_type = std::string;
1713 static constexpr size_t position{0};
1714 static constexpr char const * const name{"st_name"};
1715 static constexpr char const * const typestr{"std::string"};
1716 static constexpr bool traverse{false};
1717 static constexpr auto mbr_ptr{&SgAsmCoffSymbol::p_st_name};
1718 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1719 using bind = Desc<SgAsmCoffSymbol, std::string SgAsmCoffSymbol::*, &SgAsmCoffSymbol::p_st_name>;
1720};
1721template <> struct describe_field_t<SgAsmCoffSymbol,Rose::BinaryAnalysis::Address,&SgAsmCoffSymbol::p_st_name_offset> {
1722 using parent = SgAsmCoffSymbol;
1723 using field_type = Rose::BinaryAnalysis::Address;
1724 static constexpr size_t position{1};
1725 static constexpr char const * const name{"st_name_offset"};
1726 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
1727 static constexpr bool traverse{false};
1728 static constexpr auto mbr_ptr{&SgAsmCoffSymbol::p_st_name_offset};
1729 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1730 using bind = Desc<SgAsmCoffSymbol, Rose::BinaryAnalysis::Address SgAsmCoffSymbol::*, &SgAsmCoffSymbol::p_st_name_offset>;
1731};
1732template <> struct describe_field_t<SgAsmCoffSymbol,int,&SgAsmCoffSymbol::p_st_section_num> {
1733 using parent = SgAsmCoffSymbol;
1734 using field_type = int;
1735 static constexpr size_t position{2};
1736 static constexpr char const * const name{"st_section_num"};
1737 static constexpr char const * const typestr{"int"};
1738 static constexpr bool traverse{false};
1739 static constexpr auto mbr_ptr{&SgAsmCoffSymbol::p_st_section_num};
1740 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1741 using bind = Desc<SgAsmCoffSymbol, int SgAsmCoffSymbol::*, &SgAsmCoffSymbol::p_st_section_num>;
1742};
1743template <> struct describe_field_t<SgAsmCoffSymbol,unsigned,&SgAsmCoffSymbol::p_st_type> {
1744 using parent = SgAsmCoffSymbol;
1745 using field_type = unsigned;
1746 static constexpr size_t position{3};
1747 static constexpr char const * const name{"st_type"};
1748 static constexpr char const * const typestr{"unsigned"};
1749 static constexpr bool traverse{false};
1750 static constexpr auto mbr_ptr{&SgAsmCoffSymbol::p_st_type};
1751 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1752 using bind = Desc<SgAsmCoffSymbol, unsigned SgAsmCoffSymbol::*, &SgAsmCoffSymbol::p_st_type>;
1753};
1754template <> struct describe_field_t<SgAsmCoffSymbol,unsigned,&SgAsmCoffSymbol::p_st_storage_class> {
1755 using parent = SgAsmCoffSymbol;
1756 using field_type = unsigned;
1757 static constexpr size_t position{4};
1758 static constexpr char const * const name{"st_storage_class"};
1759 static constexpr char const * const typestr{"unsigned"};
1760 static constexpr bool traverse{false};
1761 static constexpr auto mbr_ptr{&SgAsmCoffSymbol::p_st_storage_class};
1762 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1763 using bind = Desc<SgAsmCoffSymbol, unsigned SgAsmCoffSymbol::*, &SgAsmCoffSymbol::p_st_storage_class>;
1764};
1765template <> struct describe_field_t<SgAsmCoffSymbol,unsigned,&SgAsmCoffSymbol::p_st_num_aux_entries> {
1766 using parent = SgAsmCoffSymbol;
1767 using field_type = unsigned;
1768 static constexpr size_t position{5};
1769 static constexpr char const * const name{"st_num_aux_entries"};
1770 static constexpr char const * const typestr{"unsigned"};
1771 static constexpr bool traverse{false};
1772 static constexpr auto mbr_ptr{&SgAsmCoffSymbol::p_st_num_aux_entries};
1773 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1774 using bind = Desc<SgAsmCoffSymbol, unsigned SgAsmCoffSymbol::*, &SgAsmCoffSymbol::p_st_num_aux_entries>;
1775};
1776template <> struct describe_field_t<SgAsmCoffSymbol,SgUnsignedCharList,&SgAsmCoffSymbol::p_auxiliaryData> {
1777 using parent = SgAsmCoffSymbol;
1778 using field_type = SgUnsignedCharList;
1779 static constexpr size_t position{6};
1780 static constexpr char const * const name{"auxiliaryData"};
1781 static constexpr char const * const typestr{"SgUnsignedCharList"};
1782 static constexpr bool traverse{false};
1783 static constexpr auto mbr_ptr{&SgAsmCoffSymbol::p_auxiliaryData};
1784 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1785 using bind = Desc<SgAsmCoffSymbol, SgUnsignedCharList SgAsmCoffSymbol::*, &SgAsmCoffSymbol::p_auxiliaryData>;
1786};
1796template <> struct node_from_variant_t<64> { using type = SgAsmCoffSymbol; };
1797
1798// Class: AsmCoffSymbolList
1799template <> struct describe_field_t<SgAsmCoffSymbolList,SgAsmCoffSymbolPtrList,&SgAsmCoffSymbolList::p_symbols> {
1801 using field_type = SgAsmCoffSymbolPtrList;
1802 static constexpr size_t position{0};
1803 static constexpr char const * const name{"symbols"};
1804 static constexpr char const * const typestr{"SgAsmCoffSymbolPtrList"};
1805 static constexpr bool traverse{true};
1806 static constexpr auto mbr_ptr{&SgAsmCoffSymbolList::p_symbols};
1807 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1808 using bind = Desc<SgAsmCoffSymbolList, SgAsmCoffSymbolPtrList SgAsmCoffSymbolList::*, &SgAsmCoffSymbolList::p_symbols>;
1809};
1811 using node = SgAsmCoffSymbolList;
1813 static constexpr char const * const name{"AsmCoffSymbolList"};
1814 static constexpr unsigned long variant{65};
1815 static constexpr bool concrete{true};
1816 using subclasses_t = mp::List<>;
1818};
1819template <> struct node_from_variant_t<65> { using type = SgAsmCoffSymbolList; };
1820
1821// Class: AsmCoffSymbolTable
1822template <> struct describe_field_t<SgAsmCoffSymbolTable,SgAsmGenericSection*,&SgAsmCoffSymbolTable::p_strtab> {
1825 static constexpr size_t position{0};
1826 static constexpr char const * const name{"strtab"};
1827 static constexpr char const * const typestr{"SgAsmGenericSection*"};
1828 static constexpr bool traverse{false};
1829 static constexpr auto mbr_ptr{&SgAsmCoffSymbolTable::p_strtab};
1830 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1831 using bind = Desc<SgAsmCoffSymbolTable, SgAsmGenericSection* SgAsmCoffSymbolTable::*, &SgAsmCoffSymbolTable::p_strtab>;
1832};
1833template <> struct describe_field_t<SgAsmCoffSymbolTable,SgAsmCoffSymbolList*,&SgAsmCoffSymbolTable::p_symbols> {
1836 static constexpr size_t position{1};
1837 static constexpr char const * const name{"symbols"};
1838 static constexpr char const * const typestr{"SgAsmCoffSymbolList*"};
1839 static constexpr bool traverse{true};
1840 static constexpr auto mbr_ptr{&SgAsmCoffSymbolTable::p_symbols};
1841 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1842 using bind = Desc<SgAsmCoffSymbolTable, SgAsmCoffSymbolList* SgAsmCoffSymbolTable::*, &SgAsmCoffSymbolTable::p_symbols>;
1843};
1845 using node = SgAsmCoffSymbolTable;
1846 using base = SgAsmGenericSection;
1847 static constexpr char const * const name{"AsmCoffSymbolTable"};
1848 static constexpr unsigned long variant{66};
1849 static constexpr bool concrete{true};
1850 using subclasses_t = mp::List<>;
1852};
1853template <> struct node_from_variant_t<66> { using type = SgAsmCoffSymbolTable; };
1854
1855// Class: AsmCommonSubExpression
1856template <> struct describe_field_t<SgAsmCommonSubExpression,SgAsmExpression*,&SgAsmCommonSubExpression::p_subexpression> {
1858 using field_type = SgAsmExpression*;
1859 static constexpr size_t position{0};
1860 static constexpr char const * const name{"subexpression"};
1861 static constexpr char const * const typestr{"SgAsmExpression*"};
1862 static constexpr bool traverse{true};
1863 static constexpr auto mbr_ptr{&SgAsmCommonSubExpression::p_subexpression};
1864 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1865 using bind = Desc<SgAsmCommonSubExpression, SgAsmExpression* SgAsmCommonSubExpression::*, &SgAsmCommonSubExpression::p_subexpression>;
1866};
1869 using base = SgAsmExpression;
1870 static constexpr char const * const name{"AsmCommonSubExpression"};
1871 static constexpr unsigned long variant{67};
1872 static constexpr bool concrete{true};
1873 using subclasses_t = mp::List<>;
1875};
1876template <> struct node_from_variant_t<67> { using type = SgAsmCommonSubExpression; };
1877
1878// Class: AsmControlFlagsExpression
1879template <> struct describe_field_t<SgAsmControlFlagsExpression,unsigned long,&SgAsmControlFlagsExpression::p_bitFlags> {
1881 using field_type = unsigned long;
1882 static constexpr size_t position{0};
1883 static constexpr char const * const name{"bitFlags"};
1884 static constexpr char const * const typestr{"unsigned long"};
1885 static constexpr bool traverse{false};
1886 static constexpr auto mbr_ptr{&SgAsmControlFlagsExpression::p_bitFlags};
1887 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1888 using bind = Desc<SgAsmControlFlagsExpression, unsigned long SgAsmControlFlagsExpression::*, &SgAsmControlFlagsExpression::p_bitFlags>;
1889};
1892 using base = SgAsmExpression;
1893 static constexpr char const * const name{"AsmControlFlagsExpression"};
1894 static constexpr unsigned long variant{68};
1895 static constexpr bool concrete{true};
1896 using subclasses_t = mp::List<>;
1898};
1899template <> struct node_from_variant_t<68> { using type = SgAsmControlFlagsExpression; };
1900
1901// Class: AsmConstantExpression
1902template <> struct describe_field_t<SgAsmConstantExpression,Sawyer::Container::BitVector,&SgAsmConstantExpression::p_bitVector> {
1905 static constexpr size_t position{0};
1906 static constexpr char const * const name{"bitVector"};
1907 static constexpr char const * const typestr{"Sawyer::Container::BitVector"};
1908 static constexpr bool traverse{false};
1909 static constexpr auto mbr_ptr{&SgAsmConstantExpression::p_bitVector};
1910 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1911 using bind = Desc<SgAsmConstantExpression, Sawyer::Container::BitVector SgAsmConstantExpression::*, &SgAsmConstantExpression::p_bitVector>;
1912};
1915 using base = SgAsmValueExpression;
1916 static constexpr char const * const name{"AsmConstantExpression"};
1917 static constexpr unsigned long variant{69};
1918 static constexpr bool concrete{false};
1921};
1922template <> struct node_from_variant_t<69> { using type = SgAsmConstantExpression; };
1923
1924// Class: AsmDOSExtendedHeader
1925template <> struct describe_field_t<SgAsmDOSExtendedHeader,unsigned,&SgAsmDOSExtendedHeader::p_e_res1> {
1927 using field_type = unsigned;
1928 static constexpr size_t position{0};
1929 static constexpr char const * const name{"e_res1"};
1930 static constexpr char const * const typestr{"unsigned"};
1931 static constexpr bool traverse{false};
1932 static constexpr auto mbr_ptr{&SgAsmDOSExtendedHeader::p_e_res1};
1933 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1934 using bind = Desc<SgAsmDOSExtendedHeader, unsigned SgAsmDOSExtendedHeader::*, &SgAsmDOSExtendedHeader::p_e_res1>;
1935};
1936template <> struct describe_field_t<SgAsmDOSExtendedHeader,unsigned,&SgAsmDOSExtendedHeader::p_e_oemid> {
1938 using field_type = unsigned;
1939 static constexpr size_t position{1};
1940 static constexpr char const * const name{"e_oemid"};
1941 static constexpr char const * const typestr{"unsigned"};
1942 static constexpr bool traverse{false};
1943 static constexpr auto mbr_ptr{&SgAsmDOSExtendedHeader::p_e_oemid};
1944 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1945 using bind = Desc<SgAsmDOSExtendedHeader, unsigned SgAsmDOSExtendedHeader::*, &SgAsmDOSExtendedHeader::p_e_oemid>;
1946};
1947template <> struct describe_field_t<SgAsmDOSExtendedHeader,unsigned,&SgAsmDOSExtendedHeader::p_e_oeminfo> {
1949 using field_type = unsigned;
1950 static constexpr size_t position{2};
1951 static constexpr char const * const name{"e_oeminfo"};
1952 static constexpr char const * const typestr{"unsigned"};
1953 static constexpr bool traverse{false};
1954 static constexpr auto mbr_ptr{&SgAsmDOSExtendedHeader::p_e_oeminfo};
1955 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1956 using bind = Desc<SgAsmDOSExtendedHeader, unsigned SgAsmDOSExtendedHeader::*, &SgAsmDOSExtendedHeader::p_e_oeminfo>;
1957};
1958template <> struct describe_field_t<SgAsmDOSExtendedHeader,unsigned,&SgAsmDOSExtendedHeader::p_e_res2> {
1960 using field_type = unsigned;
1961 static constexpr size_t position{3};
1962 static constexpr char const * const name{"e_res2"};
1963 static constexpr char const * const typestr{"unsigned"};
1964 static constexpr bool traverse{false};
1965 static constexpr auto mbr_ptr{&SgAsmDOSExtendedHeader::p_e_res2};
1966 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1967 using bind = Desc<SgAsmDOSExtendedHeader, unsigned SgAsmDOSExtendedHeader::*, &SgAsmDOSExtendedHeader::p_e_res2>;
1968};
1969template <> struct describe_field_t<SgAsmDOSExtendedHeader,unsigned,&SgAsmDOSExtendedHeader::p_e_res3> {
1971 using field_type = unsigned;
1972 static constexpr size_t position{4};
1973 static constexpr char const * const name{"e_res3"};
1974 static constexpr char const * const typestr{"unsigned"};
1975 static constexpr bool traverse{false};
1976 static constexpr auto mbr_ptr{&SgAsmDOSExtendedHeader::p_e_res3};
1977 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1978 using bind = Desc<SgAsmDOSExtendedHeader, unsigned SgAsmDOSExtendedHeader::*, &SgAsmDOSExtendedHeader::p_e_res3>;
1979};
1980template <> struct describe_field_t<SgAsmDOSExtendedHeader,unsigned,&SgAsmDOSExtendedHeader::p_e_res4> {
1982 using field_type = unsigned;
1983 static constexpr size_t position{5};
1984 static constexpr char const * const name{"e_res4"};
1985 static constexpr char const * const typestr{"unsigned"};
1986 static constexpr bool traverse{false};
1987 static constexpr auto mbr_ptr{&SgAsmDOSExtendedHeader::p_e_res4};
1988 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1989 using bind = Desc<SgAsmDOSExtendedHeader, unsigned SgAsmDOSExtendedHeader::*, &SgAsmDOSExtendedHeader::p_e_res4>;
1990};
1991template <> struct describe_field_t<SgAsmDOSExtendedHeader,unsigned,&SgAsmDOSExtendedHeader::p_e_res5> {
1993 using field_type = unsigned;
1994 static constexpr size_t position{6};
1995 static constexpr char const * const name{"e_res5"};
1996 static constexpr char const * const typestr{"unsigned"};
1997 static constexpr bool traverse{false};
1998 static constexpr auto mbr_ptr{&SgAsmDOSExtendedHeader::p_e_res5};
1999 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2000 using bind = Desc<SgAsmDOSExtendedHeader, unsigned SgAsmDOSExtendedHeader::*, &SgAsmDOSExtendedHeader::p_e_res5>;
2001};
2002template <> struct describe_field_t<SgAsmDOSExtendedHeader,unsigned,&SgAsmDOSExtendedHeader::p_e_res6> {
2004 using field_type = unsigned;
2005 static constexpr size_t position{7};
2006 static constexpr char const * const name{"e_res6"};
2007 static constexpr char const * const typestr{"unsigned"};
2008 static constexpr bool traverse{false};
2009 static constexpr auto mbr_ptr{&SgAsmDOSExtendedHeader::p_e_res6};
2010 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2011 using bind = Desc<SgAsmDOSExtendedHeader, unsigned SgAsmDOSExtendedHeader::*, &SgAsmDOSExtendedHeader::p_e_res6>;
2012};
2013template <> struct describe_field_t<SgAsmDOSExtendedHeader,Rose::BinaryAnalysis::Address,&SgAsmDOSExtendedHeader::p_e_lfanew> {
2015 using field_type = Rose::BinaryAnalysis::Address;
2016 static constexpr size_t position{8};
2017 static constexpr char const * const name{"e_lfanew"};
2018 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
2019 static constexpr bool traverse{false};
2020 static constexpr auto mbr_ptr{&SgAsmDOSExtendedHeader::p_e_lfanew};
2021 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2022 using bind = Desc<SgAsmDOSExtendedHeader, Rose::BinaryAnalysis::Address SgAsmDOSExtendedHeader::*, &SgAsmDOSExtendedHeader::p_e_lfanew>;
2023};
2033template <> struct node_from_variant_t<70> { using type = SgAsmDOSExtendedHeader; };
2034
2035// Class: AsmDOSFileHeader
2036template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_last_page_size> {
2037 using parent = SgAsmDOSFileHeader;
2038 using field_type = uint16_t;
2039 static constexpr size_t position{0};
2040 static constexpr char const * const name{"e_last_page_size"};
2041 static constexpr char const * const typestr{"uint16_t"};
2042 static constexpr bool traverse{false};
2043 static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_last_page_size};
2044 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2045 using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_last_page_size>;
2046};
2047template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_total_pages> {
2048 using parent = SgAsmDOSFileHeader;
2049 using field_type = uint16_t;
2050 static constexpr size_t position{1};
2051 static constexpr char const * const name{"e_total_pages"};
2052 static constexpr char const * const typestr{"uint16_t"};
2053 static constexpr bool traverse{false};
2054 static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_total_pages};
2055 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2056 using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_total_pages>;
2057};
2058template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_nrelocs> {
2059 using parent = SgAsmDOSFileHeader;
2060 using field_type = uint16_t;
2061 static constexpr size_t position{2};
2062 static constexpr char const * const name{"e_nrelocs"};
2063 static constexpr char const * const typestr{"uint16_t"};
2064 static constexpr bool traverse{false};
2065 static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_nrelocs};
2066 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2067 using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_nrelocs>;
2068};
2069template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_header_paragraphs> {
2070 using parent = SgAsmDOSFileHeader;
2071 using field_type = uint16_t;
2072 static constexpr size_t position{3};
2073 static constexpr char const * const name{"e_header_paragraphs"};
2074 static constexpr char const * const typestr{"uint16_t"};
2075 static constexpr bool traverse{false};
2076 static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_header_paragraphs};
2077 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2078 using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_header_paragraphs>;
2079};
2080template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_minalloc> {
2081 using parent = SgAsmDOSFileHeader;
2082 using field_type = uint16_t;
2083 static constexpr size_t position{4};
2084 static constexpr char const * const name{"e_minalloc"};
2085 static constexpr char const * const typestr{"uint16_t"};
2086 static constexpr bool traverse{false};
2087 static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_minalloc};
2088 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2089 using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_minalloc>;
2090};
2091template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_maxalloc> {
2092 using parent = SgAsmDOSFileHeader;
2093 using field_type = uint16_t;
2094 static constexpr size_t position{5};
2095 static constexpr char const * const name{"e_maxalloc"};
2096 static constexpr char const * const typestr{"uint16_t"};
2097 static constexpr bool traverse{false};
2098 static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_maxalloc};
2099 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2100 using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_maxalloc>;
2101};
2102template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_ss> {
2103 using parent = SgAsmDOSFileHeader;
2104 using field_type = uint16_t;
2105 static constexpr size_t position{6};
2106 static constexpr char const * const name{"e_ss"};
2107 static constexpr char const * const typestr{"uint16_t"};
2108 static constexpr bool traverse{false};
2109 static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_ss};
2110 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2111 using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_ss>;
2112};
2113template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_sp> {
2114 using parent = SgAsmDOSFileHeader;
2115 using field_type = uint16_t;
2116 static constexpr size_t position{7};
2117 static constexpr char const * const name{"e_sp"};
2118 static constexpr char const * const typestr{"uint16_t"};
2119 static constexpr bool traverse{false};
2120 static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_sp};
2121 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2122 using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_sp>;
2123};
2124template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_cksum> {
2125 using parent = SgAsmDOSFileHeader;
2126 using field_type = uint16_t;
2127 static constexpr size_t position{8};
2128 static constexpr char const * const name{"e_cksum"};
2129 static constexpr char const * const typestr{"uint16_t"};
2130 static constexpr bool traverse{false};
2131 static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_cksum};
2132 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2133 using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_cksum>;
2134};
2135template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_ip> {
2136 using parent = SgAsmDOSFileHeader;
2137 using field_type = uint16_t;
2138 static constexpr size_t position{9};
2139 static constexpr char const * const name{"e_ip"};
2140 static constexpr char const * const typestr{"uint16_t"};
2141 static constexpr bool traverse{false};
2142 static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_ip};
2143 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2144 using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_ip>;
2145};
2146template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_cs> {
2147 using parent = SgAsmDOSFileHeader;
2148 using field_type = uint16_t;
2149 static constexpr size_t position{10};
2150 static constexpr char const * const name{"e_cs"};
2151 static constexpr char const * const typestr{"uint16_t"};
2152 static constexpr bool traverse{false};
2153 static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_cs};
2154 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2155 using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_cs>;
2156};
2157template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_overlay> {
2158 using parent = SgAsmDOSFileHeader;
2159 using field_type = uint16_t;
2160 static constexpr size_t position{11};
2161 static constexpr char const * const name{"e_overlay"};
2162 static constexpr char const * const typestr{"uint16_t"};
2163 static constexpr bool traverse{false};
2164 static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_overlay};
2165 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2166 using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_overlay>;
2167};
2168template <> struct describe_field_t<SgAsmDOSFileHeader,Rose::BinaryAnalysis::Address,&SgAsmDOSFileHeader::p_e_relocs_offset> {
2169 using parent = SgAsmDOSFileHeader;
2170 using field_type = Rose::BinaryAnalysis::Address;
2171 static constexpr size_t position{12};
2172 static constexpr char const * const name{"e_relocs_offset"};
2173 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
2174 static constexpr bool traverse{false};
2175 static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_relocs_offset};
2176 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2177 using bind = Desc<SgAsmDOSFileHeader, Rose::BinaryAnalysis::Address SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_relocs_offset>;
2178};
2179template <> struct describe_field_t<SgAsmDOSFileHeader,unsigned,&SgAsmDOSFileHeader::p_e_res1> {
2180 using parent = SgAsmDOSFileHeader;
2181 using field_type = unsigned;
2182 static constexpr size_t position{13};
2183 static constexpr char const * const name{"e_res1"};
2184 static constexpr char const * const typestr{"unsigned"};
2185 static constexpr bool traverse{false};
2186 static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_res1};
2187 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2188 using bind = Desc<SgAsmDOSFileHeader, unsigned SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_res1>;
2189};
2190template <> struct describe_field_t<SgAsmDOSFileHeader,SgAsmGenericSection*,&SgAsmDOSFileHeader::p_relocs> {
2191 using parent = SgAsmDOSFileHeader;
2193 static constexpr size_t position{14};
2194 static constexpr char const * const name{"relocs"};
2195 static constexpr char const * const typestr{"SgAsmGenericSection*"};
2196 static constexpr bool traverse{false};
2197 static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_relocs};
2198 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2199 using bind = Desc<SgAsmDOSFileHeader, SgAsmGenericSection* SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_relocs>;
2200};
2201template <> struct describe_field_t<SgAsmDOSFileHeader,SgAsmGenericSection*,&SgAsmDOSFileHeader::p_rm_section> {
2202 using parent = SgAsmDOSFileHeader;
2204 static constexpr size_t position{15};
2205 static constexpr char const * const name{"rm_section"};
2206 static constexpr char const * const typestr{"SgAsmGenericSection*"};
2207 static constexpr bool traverse{false};
2208 static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_rm_section};
2209 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2210 using bind = Desc<SgAsmDOSFileHeader, SgAsmGenericSection* SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_rm_section>;
2211};
2213 using node = SgAsmDOSFileHeader;
2214 using base = SgAsmGenericHeader;
2215 static constexpr char const * const name{"AsmDOSFileHeader"};
2216 static constexpr unsigned long variant{71};
2217 static constexpr bool concrete{true};
2218 using subclasses_t = mp::List<>;
2220};
2221template <> struct node_from_variant_t<71> { using type = SgAsmDOSFileHeader; };
2222
2223// Class: AsmSynthesizedDataStructureDeclaration
2227 static constexpr char const * const name{"AsmSynthesizedDataStructureDeclaration"};
2228 static constexpr unsigned long variant{72};
2229 static constexpr bool concrete{true};
2230 using subclasses_t = mp::List<>;
2231 using fields_t = mp::List<>;
2232};
2233template <> struct node_from_variant_t<72> { using type = SgAsmSynthesizedDataStructureDeclaration; };
2234
2235// Class: AsmSynthesizedDeclaration
2238 using base = SgAsmStatement;
2239 static constexpr char const * const name{"AsmSynthesizedDeclaration"};
2240 static constexpr unsigned long variant{73};
2241 static constexpr bool concrete{false};
2243 using fields_t = mp::List<>;
2244};
2245template <> struct node_from_variant_t<73> { using type = SgAsmSynthesizedDeclaration; };
2246
2247// Class: AsmDirectRegisterExpression
2251 static constexpr char const * const name{"AsmDirectRegisterExpression"};
2252 static constexpr unsigned long variant{74};
2253 static constexpr bool concrete{true};
2254 using subclasses_t = mp::List<>;
2255 using fields_t = mp::List<>;
2256};
2257template <> struct node_from_variant_t<74> { using type = SgAsmDirectRegisterExpression; };
2258
2259// Class: AsmDwarfAccessDeclaration
2262 using base = SgAsmDwarfConstruct;
2263 static constexpr char const * const name{"AsmDwarfAccessDeclaration"};
2264 static constexpr unsigned long variant{75};
2265 static constexpr bool concrete{true};
2266 using subclasses_t = mp::List<>;
2267 using fields_t = mp::List<>;
2268};
2269template <> struct node_from_variant_t<75> { using type = SgAsmDwarfAccessDeclaration; };
2270
2271// Class: AsmDwarfArrayType
2272template <> struct describe_field_t<SgAsmDwarfArrayType,SgAsmDwarfConstructList*,&SgAsmDwarfArrayType::p_body> {
2275 static constexpr size_t position{0};
2276 static constexpr char const * const name{"body"};
2277 static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
2278 static constexpr bool traverse{true};
2279 static constexpr auto mbr_ptr{&SgAsmDwarfArrayType::p_body};
2280 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2281 using bind = Desc<SgAsmDwarfArrayType, SgAsmDwarfConstructList* SgAsmDwarfArrayType::*, &SgAsmDwarfArrayType::p_body>;
2282};
2284 using node = SgAsmDwarfArrayType;
2285 using base = SgAsmDwarfConstruct;
2286 static constexpr char const * const name{"AsmDwarfArrayType"};
2287 static constexpr unsigned long variant{76};
2288 static constexpr bool concrete{true};
2289 using subclasses_t = mp::List<>;
2291};
2292template <> struct node_from_variant_t<76> { using type = SgAsmDwarfArrayType; };
2293
2294// Class: AsmDwarfBaseType
2296 using node = SgAsmDwarfBaseType;
2297 using base = SgAsmDwarfConstruct;
2298 static constexpr char const * const name{"AsmDwarfBaseType"};
2299 static constexpr unsigned long variant{77};
2300 static constexpr bool concrete{true};
2301 using subclasses_t = mp::List<>;
2302 using fields_t = mp::List<>;
2303};
2304template <> struct node_from_variant_t<77> { using type = SgAsmDwarfBaseType; };
2305
2306// Class: AsmDwarfCatchBlock
2308 using node = SgAsmDwarfCatchBlock;
2309 using base = SgAsmDwarfConstruct;
2310 static constexpr char const * const name{"AsmDwarfCatchBlock"};
2311 static constexpr unsigned long variant{78};
2312 static constexpr bool concrete{true};
2313 using subclasses_t = mp::List<>;
2314 using fields_t = mp::List<>;
2315};
2316template <> struct node_from_variant_t<78> { using type = SgAsmDwarfCatchBlock; };
2317
2318// Class: AsmDwarfClassTemplate
2321 using base = SgAsmDwarfConstruct;
2322 static constexpr char const * const name{"AsmDwarfClassTemplate"};
2323 static constexpr unsigned long variant{79};
2324 static constexpr bool concrete{true};
2325 using subclasses_t = mp::List<>;
2326 using fields_t = mp::List<>;
2327};
2328template <> struct node_from_variant_t<79> { using type = SgAsmDwarfClassTemplate; };
2329
2330// Class: AsmDwarfClassType
2331template <> struct describe_field_t<SgAsmDwarfClassType,SgAsmDwarfConstructList*,&SgAsmDwarfClassType::p_body> {
2334 static constexpr size_t position{0};
2335 static constexpr char const * const name{"body"};
2336 static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
2337 static constexpr bool traverse{true};
2338 static constexpr auto mbr_ptr{&SgAsmDwarfClassType::p_body};
2339 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2340 using bind = Desc<SgAsmDwarfClassType, SgAsmDwarfConstructList* SgAsmDwarfClassType::*, &SgAsmDwarfClassType::p_body>;
2341};
2343 using node = SgAsmDwarfClassType;
2344 using base = SgAsmDwarfConstruct;
2345 static constexpr char const * const name{"AsmDwarfClassType"};
2346 static constexpr unsigned long variant{80};
2347 static constexpr bool concrete{true};
2348 using subclasses_t = mp::List<>;
2350};
2351template <> struct node_from_variant_t<80> { using type = SgAsmDwarfClassType; };
2352
2353// Class: AsmDwarfCommonBlock
2354template <> struct describe_field_t<SgAsmDwarfCommonBlock,SgAsmDwarfConstructList*,&SgAsmDwarfCommonBlock::p_body> {
2357 static constexpr size_t position{0};
2358 static constexpr char const * const name{"body"};
2359 static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
2360 static constexpr bool traverse{true};
2361 static constexpr auto mbr_ptr{&SgAsmDwarfCommonBlock::p_body};
2362 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2363 using bind = Desc<SgAsmDwarfCommonBlock, SgAsmDwarfConstructList* SgAsmDwarfCommonBlock::*, &SgAsmDwarfCommonBlock::p_body>;
2364};
2367 using base = SgAsmDwarfConstruct;
2368 static constexpr char const * const name{"AsmDwarfCommonBlock"};
2369 static constexpr unsigned long variant{81};
2370 static constexpr bool concrete{true};
2371 using subclasses_t = mp::List<>;
2373};
2374template <> struct node_from_variant_t<81> { using type = SgAsmDwarfCommonBlock; };
2375
2376// Class: AsmDwarfCommonInclusion
2379 using base = SgAsmDwarfConstruct;
2380 static constexpr char const * const name{"AsmDwarfCommonInclusion"};
2381 static constexpr unsigned long variant{82};
2382 static constexpr bool concrete{true};
2383 using subclasses_t = mp::List<>;
2384 using fields_t = mp::List<>;
2385};
2386template <> struct node_from_variant_t<82> { using type = SgAsmDwarfCommonInclusion; };
2387
2388// Class: AsmDwarfCompilationUnit
2389template <> struct describe_field_t<SgAsmDwarfCompilationUnit,std::string,&SgAsmDwarfCompilationUnit::p_producer> {
2391 using field_type = std::string;
2392 static constexpr size_t position{0};
2393 static constexpr char const * const name{"producer"};
2394 static constexpr char const * const typestr{"std::string"};
2395 static constexpr bool traverse{false};
2396 static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnit::p_producer};
2397 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2398 using bind = Desc<SgAsmDwarfCompilationUnit, std::string SgAsmDwarfCompilationUnit::*, &SgAsmDwarfCompilationUnit::p_producer>;
2399};
2400template <> struct describe_field_t<SgAsmDwarfCompilationUnit,std::string,&SgAsmDwarfCompilationUnit::p_language> {
2402 using field_type = std::string;
2403 static constexpr size_t position{1};
2404 static constexpr char const * const name{"language"};
2405 static constexpr char const * const typestr{"std::string"};
2406 static constexpr bool traverse{false};
2407 static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnit::p_language};
2408 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2409 using bind = Desc<SgAsmDwarfCompilationUnit, std::string SgAsmDwarfCompilationUnit::*, &SgAsmDwarfCompilationUnit::p_language>;
2410};
2411template <> struct describe_field_t<SgAsmDwarfCompilationUnit,uint64_t,&SgAsmDwarfCompilationUnit::p_low_pc> {
2413 using field_type = uint64_t;
2414 static constexpr size_t position{2};
2415 static constexpr char const * const name{"low_pc"};
2416 static constexpr char const * const typestr{"uint64_t"};
2417 static constexpr bool traverse{false};
2418 static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnit::p_low_pc};
2419 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2420 using bind = Desc<SgAsmDwarfCompilationUnit, uint64_t SgAsmDwarfCompilationUnit::*, &SgAsmDwarfCompilationUnit::p_low_pc>;
2421};
2422template <> struct describe_field_t<SgAsmDwarfCompilationUnit,uint64_t,&SgAsmDwarfCompilationUnit::p_hi_pc> {
2424 using field_type = uint64_t;
2425 static constexpr size_t position{3};
2426 static constexpr char const * const name{"hi_pc"};
2427 static constexpr char const * const typestr{"uint64_t"};
2428 static constexpr bool traverse{false};
2429 static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnit::p_hi_pc};
2430 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2431 using bind = Desc<SgAsmDwarfCompilationUnit, uint64_t SgAsmDwarfCompilationUnit::*, &SgAsmDwarfCompilationUnit::p_hi_pc>;
2432};
2433template <> struct describe_field_t<SgAsmDwarfCompilationUnit,int,&SgAsmDwarfCompilationUnit::p_version_stamp> {
2435 using field_type = int;
2436 static constexpr size_t position{4};
2437 static constexpr char const * const name{"version_stamp"};
2438 static constexpr char const * const typestr{"int"};
2439 static constexpr bool traverse{false};
2440 static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnit::p_version_stamp};
2441 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2442 using bind = Desc<SgAsmDwarfCompilationUnit, int SgAsmDwarfCompilationUnit::*, &SgAsmDwarfCompilationUnit::p_version_stamp>;
2443};
2444template <> struct describe_field_t<SgAsmDwarfCompilationUnit,uint64_t,&SgAsmDwarfCompilationUnit::p_abbrev_offset> {
2446 using field_type = uint64_t;
2447 static constexpr size_t position{5};
2448 static constexpr char const * const name{"abbrev_offset"};
2449 static constexpr char const * const typestr{"uint64_t"};
2450 static constexpr bool traverse{false};
2451 static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnit::p_abbrev_offset};
2452 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2453 using bind = Desc<SgAsmDwarfCompilationUnit, uint64_t SgAsmDwarfCompilationUnit::*, &SgAsmDwarfCompilationUnit::p_abbrev_offset>;
2454};
2455template <> struct describe_field_t<SgAsmDwarfCompilationUnit,uint64_t,&SgAsmDwarfCompilationUnit::p_address_size> {
2457 using field_type = uint64_t;
2458 static constexpr size_t position{6};
2459 static constexpr char const * const name{"address_size"};
2460 static constexpr char const * const typestr{"uint64_t"};
2461 static constexpr bool traverse{false};
2462 static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnit::p_address_size};
2463 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2464 using bind = Desc<SgAsmDwarfCompilationUnit, uint64_t SgAsmDwarfCompilationUnit::*, &SgAsmDwarfCompilationUnit::p_address_size>;
2465};
2466template <> struct describe_field_t<SgAsmDwarfCompilationUnit,uint64_t,&SgAsmDwarfCompilationUnit::p_offset_length> {
2468 using field_type = uint64_t;
2469 static constexpr size_t position{7};
2470 static constexpr char const * const name{"offset_length"};
2471 static constexpr char const * const typestr{"uint64_t"};
2472 static constexpr bool traverse{false};
2473 static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnit::p_offset_length};
2474 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2475 using bind = Desc<SgAsmDwarfCompilationUnit, uint64_t SgAsmDwarfCompilationUnit::*, &SgAsmDwarfCompilationUnit::p_offset_length>;
2476};
2477template <> struct describe_field_t<SgAsmDwarfCompilationUnit,SgAsmDwarfLineList*,&SgAsmDwarfCompilationUnit::p_line_info> {
2480 static constexpr size_t position{8};
2481 static constexpr char const * const name{"line_info"};
2482 static constexpr char const * const typestr{"SgAsmDwarfLineList*"};
2483 static constexpr bool traverse{true};
2484 static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnit::p_line_info};
2485 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2486 using bind = Desc<SgAsmDwarfCompilationUnit, SgAsmDwarfLineList* SgAsmDwarfCompilationUnit::*, &SgAsmDwarfCompilationUnit::p_line_info>;
2487};
2488template <> struct describe_field_t<SgAsmDwarfCompilationUnit,SgAsmDwarfConstructList*,&SgAsmDwarfCompilationUnit::p_language_constructs> {
2491 static constexpr size_t position{9};
2492 static constexpr char const * const name{"language_constructs"};
2493 static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
2494 static constexpr bool traverse{true};
2495 static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnit::p_language_constructs};
2496 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2497 using bind = Desc<SgAsmDwarfCompilationUnit, SgAsmDwarfConstructList* SgAsmDwarfCompilationUnit::*, &SgAsmDwarfCompilationUnit::p_language_constructs>;
2498};
2499template <> struct describe_field_t<SgAsmDwarfCompilationUnit,SgAsmDwarfMacroList*,&SgAsmDwarfCompilationUnit::p_macro_info> {
2502 static constexpr size_t position{10};
2503 static constexpr char const * const name{"macro_info"};
2504 static constexpr char const * const typestr{"SgAsmDwarfMacroList*"};
2505 static constexpr bool traverse{true};
2506 static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnit::p_macro_info};
2507 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2508 using bind = Desc<SgAsmDwarfCompilationUnit, SgAsmDwarfMacroList* SgAsmDwarfCompilationUnit::*, &SgAsmDwarfCompilationUnit::p_macro_info>;
2509};
2519template <> struct node_from_variant_t<83> { using type = SgAsmDwarfCompilationUnit; };
2520
2521// Class: AsmDwarfCompilationUnitList
2522template <> struct describe_field_t<SgAsmDwarfCompilationUnitList,SgAsmDwarfCompilationUnitPtrList,&SgAsmDwarfCompilationUnitList::p_cu_list> {
2524 using field_type = SgAsmDwarfCompilationUnitPtrList;
2525 static constexpr size_t position{0};
2526 static constexpr char const * const name{"cu_list"};
2527 static constexpr char const * const typestr{"SgAsmDwarfCompilationUnitPtrList"};
2528 static constexpr bool traverse{true};
2529 static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnitList::p_cu_list};
2530 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2531 using bind = Desc<SgAsmDwarfCompilationUnitList, SgAsmDwarfCompilationUnitPtrList SgAsmDwarfCompilationUnitList::*, &SgAsmDwarfCompilationUnitList::p_cu_list>;
2532};
2536 static constexpr char const * const name{"AsmDwarfCompilationUnitList"};
2537 static constexpr unsigned long variant{84};
2538 static constexpr bool concrete{true};
2539 using subclasses_t = mp::List<>;
2541};
2542template <> struct node_from_variant_t<84> { using type = SgAsmDwarfCompilationUnitList; };
2543
2544// Class: AsmDwarfCondition
2546 using node = SgAsmDwarfCondition;
2547 using base = SgAsmDwarfConstruct;
2548 static constexpr char const * const name{"AsmDwarfCondition"};
2549 static constexpr unsigned long variant{85};
2550 static constexpr bool concrete{true};
2551 using subclasses_t = mp::List<>;
2552 using fields_t = mp::List<>;
2553};
2554template <> struct node_from_variant_t<85> { using type = SgAsmDwarfCondition; };
2555
2556// Class: AsmDwarfConstType
2558 using node = SgAsmDwarfConstType;
2559 using base = SgAsmDwarfConstruct;
2560 static constexpr char const * const name{"AsmDwarfConstType"};
2561 static constexpr unsigned long variant{86};
2562 static constexpr bool concrete{true};
2563 using subclasses_t = mp::List<>;
2564 using fields_t = mp::List<>;
2565};
2566template <> struct node_from_variant_t<86> { using type = SgAsmDwarfConstType; };
2567
2568// Class: AsmDwarfConstant
2570 using node = SgAsmDwarfConstant;
2571 using base = SgAsmDwarfConstruct;
2572 static constexpr char const * const name{"AsmDwarfConstant"};
2573 static constexpr unsigned long variant{87};
2574 static constexpr bool concrete{true};
2575 using subclasses_t = mp::List<>;
2576 using fields_t = mp::List<>;
2577};
2578template <> struct node_from_variant_t<87> { using type = SgAsmDwarfConstant; };
2579
2580// Class: AsmDwarfConstruct
2581template <> struct describe_field_t<SgAsmDwarfConstruct,int,&SgAsmDwarfConstruct::p_nesting_level> {
2583 using field_type = int;
2584 static constexpr size_t position{0};
2585 static constexpr char const * const name{"nesting_level"};
2586 static constexpr char const * const typestr{"int"};
2587 static constexpr bool traverse{false};
2588 static constexpr auto mbr_ptr{&SgAsmDwarfConstruct::p_nesting_level};
2589 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2590 using bind = Desc<SgAsmDwarfConstruct, int SgAsmDwarfConstruct::*, &SgAsmDwarfConstruct::p_nesting_level>;
2591};
2592template <> struct describe_field_t<SgAsmDwarfConstruct,uint64_t,&SgAsmDwarfConstruct::p_offset> {
2594 using field_type = uint64_t;
2595 static constexpr size_t position{1};
2596 static constexpr char const * const name{"offset"};
2597 static constexpr char const * const typestr{"uint64_t"};
2598 static constexpr bool traverse{false};
2599 static constexpr auto mbr_ptr{&SgAsmDwarfConstruct::p_offset};
2600 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2601 using bind = Desc<SgAsmDwarfConstruct, uint64_t SgAsmDwarfConstruct::*, &SgAsmDwarfConstruct::p_offset>;
2602};
2603template <> struct describe_field_t<SgAsmDwarfConstruct,uint64_t,&SgAsmDwarfConstruct::p_overall_offset> {
2605 using field_type = uint64_t;
2606 static constexpr size_t position{2};
2607 static constexpr char const * const name{"overall_offset"};
2608 static constexpr char const * const typestr{"uint64_t"};
2609 static constexpr bool traverse{false};
2610 static constexpr auto mbr_ptr{&SgAsmDwarfConstruct::p_overall_offset};
2611 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2612 using bind = Desc<SgAsmDwarfConstruct, uint64_t SgAsmDwarfConstruct::*, &SgAsmDwarfConstruct::p_overall_offset>;
2613};
2614template <> struct describe_field_t<SgAsmDwarfConstruct,std::string,&SgAsmDwarfConstruct::p_name> {
2616 using field_type = std::string;
2617 static constexpr size_t position{3};
2618 static constexpr char const * const name{"name"};
2619 static constexpr char const * const typestr{"std::string"};
2620 static constexpr bool traverse{false};
2621 static constexpr auto mbr_ptr{&SgAsmDwarfConstruct::p_name};
2622 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2623 using bind = Desc<SgAsmDwarfConstruct, std::string SgAsmDwarfConstruct::*, &SgAsmDwarfConstruct::p_name>;
2624};
2625template <> struct describe_field_t<SgAsmDwarfConstruct,SgAsmDwarfLine*,&SgAsmDwarfConstruct::p_source_position> {
2627 using field_type = SgAsmDwarfLine*;
2628 static constexpr size_t position{4};
2629 static constexpr char const * const name{"source_position"};
2630 static constexpr char const * const typestr{"SgAsmDwarfLine*"};
2631 static constexpr bool traverse{false};
2632 static constexpr auto mbr_ptr{&SgAsmDwarfConstruct::p_source_position};
2633 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2634 using bind = Desc<SgAsmDwarfConstruct, SgAsmDwarfLine* SgAsmDwarfConstruct::*, &SgAsmDwarfConstruct::p_source_position>;
2635};
2637 using node = SgAsmDwarfConstruct;
2639 static constexpr char const * const name{"AsmDwarfConstruct"};
2640 static constexpr unsigned long variant{88};
2641 static constexpr bool concrete{false};
2642 using subclasses_t = mp::List<SgAsmDwarfAccessDeclaration, SgAsmDwarfArrayType, SgAsmDwarfBaseType, SgAsmDwarfCatchBlock, SgAsmDwarfClassTemplate, SgAsmDwarfClassType, SgAsmDwarfCommonBlock, SgAsmDwarfCommonInclusion, SgAsmDwarfCompilationUnit, SgAsmDwarfCondition, SgAsmDwarfConstant, SgAsmDwarfConstType, SgAsmDwarfDwarfProcedure, SgAsmDwarfEntryPoint, SgAsmDwarfEnumerationType, SgAsmDwarfEnumerator, SgAsmDwarfFileType, SgAsmDwarfFormalParameter, SgAsmDwarfFormatLabel, SgAsmDwarfFriend, SgAsmDwarfFunctionTemplate, SgAsmDwarfImportedDeclaration, SgAsmDwarfImportedModule, SgAsmDwarfImportedUnit, SgAsmDwarfInheritance, SgAsmDwarfInlinedSubroutine, SgAsmDwarfInterfaceType, SgAsmDwarfLabel, SgAsmDwarfLexicalBlock, SgAsmDwarfMember, SgAsmDwarfModule, SgAsmDwarfMutableType, SgAsmDwarfNamelist, SgAsmDwarfNamelistItem, SgAsmDwarfNamespace, SgAsmDwarfPackedType, SgAsmDwarfPartialUnit, SgAsmDwarfPointerType, SgAsmDwarfPtrToMemberType, SgAsmDwarfReferenceType, SgAsmDwarfRestrictType, SgAsmDwarfSetType, SgAsmDwarfSharedType, SgAsmDwarfStringType, SgAsmDwarfStructureType, SgAsmDwarfSubprogram, SgAsmDwarfSubrangeType, SgAsmDwarfSubroutineType, SgAsmDwarfTemplateTypeParameter, SgAsmDwarfTemplateValueParameter, SgAsmDwarfThrownType, SgAsmDwarfTryBlock, SgAsmDwarfTypedef, SgAsmDwarfUnionType, SgAsmDwarfUnknownConstruct, SgAsmDwarfUnspecifiedParameters, SgAsmDwarfUnspecifiedType, SgAsmDwarfUpcRelaxedType, SgAsmDwarfUpcSharedType, SgAsmDwarfUpcStrictType, SgAsmDwarfVariable, SgAsmDwarfVariant, SgAsmDwarfVariantPart, SgAsmDwarfVolatileType, SgAsmDwarfWithStmt>;
2644};
2645template <> struct node_from_variant_t<88> { using type = SgAsmDwarfConstruct; };
2646
2647// Class: AsmDwarfConstructList
2648template <> struct describe_field_t<SgAsmDwarfConstructList,SgAsmDwarfConstructPtrList,&SgAsmDwarfConstructList::p_list> {
2650 using field_type = SgAsmDwarfConstructPtrList;
2651 static constexpr size_t position{0};
2652 static constexpr char const * const name{"list"};
2653 static constexpr char const * const typestr{"SgAsmDwarfConstructPtrList"};
2654 static constexpr bool traverse{true};
2655 static constexpr auto mbr_ptr{&SgAsmDwarfConstructList::p_list};
2656 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2657 using bind = Desc<SgAsmDwarfConstructList, SgAsmDwarfConstructPtrList SgAsmDwarfConstructList::*, &SgAsmDwarfConstructList::p_list>;
2658};
2662 static constexpr char const * const name{"AsmDwarfConstructList"};
2663 static constexpr unsigned long variant{89};
2664 static constexpr bool concrete{true};
2665 using subclasses_t = mp::List<>;
2667};
2668template <> struct node_from_variant_t<89> { using type = SgAsmDwarfConstructList; };
2669
2670// Class: AsmDwarfDwarfProcedure
2673 using base = SgAsmDwarfConstruct;
2674 static constexpr char const * const name{"AsmDwarfDwarfProcedure"};
2675 static constexpr unsigned long variant{90};
2676 static constexpr bool concrete{true};
2677 using subclasses_t = mp::List<>;
2678 using fields_t = mp::List<>;
2679};
2680template <> struct node_from_variant_t<90> { using type = SgAsmDwarfDwarfProcedure; };
2681
2682// Class: AsmDwarfEntryPoint
2684 using node = SgAsmDwarfEntryPoint;
2685 using base = SgAsmDwarfConstruct;
2686 static constexpr char const * const name{"AsmDwarfEntryPoint"};
2687 static constexpr unsigned long variant{91};
2688 static constexpr bool concrete{true};
2689 using subclasses_t = mp::List<>;
2690 using fields_t = mp::List<>;
2691};
2692template <> struct node_from_variant_t<91> { using type = SgAsmDwarfEntryPoint; };
2693
2694// Class: AsmDwarfEnumerationType
2695template <> struct describe_field_t<SgAsmDwarfEnumerationType,SgAsmDwarfConstructList*,&SgAsmDwarfEnumerationType::p_body> {
2698 static constexpr size_t position{0};
2699 static constexpr char const * const name{"body"};
2700 static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
2701 static constexpr bool traverse{true};
2702 static constexpr auto mbr_ptr{&SgAsmDwarfEnumerationType::p_body};
2703 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2704 using bind = Desc<SgAsmDwarfEnumerationType, SgAsmDwarfConstructList* SgAsmDwarfEnumerationType::*, &SgAsmDwarfEnumerationType::p_body>;
2705};
2708 using base = SgAsmDwarfConstruct;
2709 static constexpr char const * const name{"AsmDwarfEnumerationType"};
2710 static constexpr unsigned long variant{92};
2711 static constexpr bool concrete{true};
2712 using subclasses_t = mp::List<>;
2714};
2715template <> struct node_from_variant_t<92> { using type = SgAsmDwarfEnumerationType; };
2716
2717// Class: AsmDwarfEnumerator
2719 using node = SgAsmDwarfEnumerator;
2720 using base = SgAsmDwarfConstruct;
2721 static constexpr char const * const name{"AsmDwarfEnumerator"};
2722 static constexpr unsigned long variant{93};
2723 static constexpr bool concrete{true};
2724 using subclasses_t = mp::List<>;
2725 using fields_t = mp::List<>;
2726};
2727template <> struct node_from_variant_t<93> { using type = SgAsmDwarfEnumerator; };
2728
2729// Class: AsmDwarfFileType
2731 using node = SgAsmDwarfFileType;
2732 using base = SgAsmDwarfConstruct;
2733 static constexpr char const * const name{"AsmDwarfFileType"};
2734 static constexpr unsigned long variant{94};
2735 static constexpr bool concrete{true};
2736 using subclasses_t = mp::List<>;
2737 using fields_t = mp::List<>;
2738};
2739template <> struct node_from_variant_t<94> { using type = SgAsmDwarfFileType; };
2740
2741// Class: AsmDwarfFormalParameter
2744 using base = SgAsmDwarfConstruct;
2745 static constexpr char const * const name{"AsmDwarfFormalParameter"};
2746 static constexpr unsigned long variant{95};
2747 static constexpr bool concrete{true};
2748 using subclasses_t = mp::List<>;
2749 using fields_t = mp::List<>;
2750};
2751template <> struct node_from_variant_t<95> { using type = SgAsmDwarfFormalParameter; };
2752
2753// Class: AsmDwarfFormatLabel
2756 using base = SgAsmDwarfConstruct;
2757 static constexpr char const * const name{"AsmDwarfFormatLabel"};
2758 static constexpr unsigned long variant{96};
2759 static constexpr bool concrete{true};
2760 using subclasses_t = mp::List<>;
2761 using fields_t = mp::List<>;
2762};
2763template <> struct node_from_variant_t<96> { using type = SgAsmDwarfFormatLabel; };
2764
2765// Class: AsmDwarfFriend
2767 using node = SgAsmDwarfFriend;
2768 using base = SgAsmDwarfConstruct;
2769 static constexpr char const * const name{"AsmDwarfFriend"};
2770 static constexpr unsigned long variant{97};
2771 static constexpr bool concrete{true};
2772 using subclasses_t = mp::List<>;
2773 using fields_t = mp::List<>;
2774};
2775template <> struct node_from_variant_t<97> { using type = SgAsmDwarfFriend; };
2776
2777// Class: AsmDwarfFunctionTemplate
2780 using base = SgAsmDwarfConstruct;
2781 static constexpr char const * const name{"AsmDwarfFunctionTemplate"};
2782 static constexpr unsigned long variant{98};
2783 static constexpr bool concrete{true};
2784 using subclasses_t = mp::List<>;
2785 using fields_t = mp::List<>;
2786};
2787template <> struct node_from_variant_t<98> { using type = SgAsmDwarfFunctionTemplate; };
2788
2789// Class: AsmDwarfImportedDeclaration
2792 using base = SgAsmDwarfConstruct;
2793 static constexpr char const * const name{"AsmDwarfImportedDeclaration"};
2794 static constexpr unsigned long variant{99};
2795 static constexpr bool concrete{true};
2796 using subclasses_t = mp::List<>;
2797 using fields_t = mp::List<>;
2798};
2799template <> struct node_from_variant_t<99> { using type = SgAsmDwarfImportedDeclaration; };
2800
2801// Class: AsmDwarfImportedModule
2804 using base = SgAsmDwarfConstruct;
2805 static constexpr char const * const name{"AsmDwarfImportedModule"};
2806 static constexpr unsigned long variant{100};
2807 static constexpr bool concrete{true};
2808 using subclasses_t = mp::List<>;
2809 using fields_t = mp::List<>;
2810};
2811template <> struct node_from_variant_t<100> { using type = SgAsmDwarfImportedModule; };
2812
2813// Class: AsmDwarfImportedUnit
2816 using base = SgAsmDwarfConstruct;
2817 static constexpr char const * const name{"AsmDwarfImportedUnit"};
2818 static constexpr unsigned long variant{101};
2819 static constexpr bool concrete{true};
2820 using subclasses_t = mp::List<>;
2821 using fields_t = mp::List<>;
2822};
2823template <> struct node_from_variant_t<101> { using type = SgAsmDwarfImportedUnit; };
2824
2825// Class: AsmDwarfInformation
2829 static constexpr char const * const name{"AsmDwarfInformation"};
2830 static constexpr unsigned long variant{102};
2831 static constexpr bool concrete{false};
2833 using fields_t = mp::List<>;
2834};
2835template <> struct node_from_variant_t<102> { using type = SgAsmDwarfInformation; };
2836
2837// Class: AsmDwarfInheritance
2840 using base = SgAsmDwarfConstruct;
2841 static constexpr char const * const name{"AsmDwarfInheritance"};
2842 static constexpr unsigned long variant{103};
2843 static constexpr bool concrete{true};
2844 using subclasses_t = mp::List<>;
2845 using fields_t = mp::List<>;
2846};
2847template <> struct node_from_variant_t<103> { using type = SgAsmDwarfInheritance; };
2848
2849// Class: AsmDwarfInlinedSubroutine
2850template <> struct describe_field_t<SgAsmDwarfInlinedSubroutine,SgAsmDwarfConstructList*,&SgAsmDwarfInlinedSubroutine::p_body> {
2853 static constexpr size_t position{0};
2854 static constexpr char const * const name{"body"};
2855 static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
2856 static constexpr bool traverse{true};
2857 static constexpr auto mbr_ptr{&SgAsmDwarfInlinedSubroutine::p_body};
2858 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2859 using bind = Desc<SgAsmDwarfInlinedSubroutine, SgAsmDwarfConstructList* SgAsmDwarfInlinedSubroutine::*, &SgAsmDwarfInlinedSubroutine::p_body>;
2860};
2863 using base = SgAsmDwarfConstruct;
2864 static constexpr char const * const name{"AsmDwarfInlinedSubroutine"};
2865 static constexpr unsigned long variant{104};
2866 static constexpr bool concrete{true};
2867 using subclasses_t = mp::List<>;
2869};
2870template <> struct node_from_variant_t<104> { using type = SgAsmDwarfInlinedSubroutine; };
2871
2872// Class: AsmDwarfInterfaceType
2875 using base = SgAsmDwarfConstruct;
2876 static constexpr char const * const name{"AsmDwarfInterfaceType"};
2877 static constexpr unsigned long variant{105};
2878 static constexpr bool concrete{true};
2879 using subclasses_t = mp::List<>;
2880 using fields_t = mp::List<>;
2881};
2882template <> struct node_from_variant_t<105> { using type = SgAsmDwarfInterfaceType; };
2883
2884// Class: AsmDwarfLabel
2886 using node = SgAsmDwarfLabel;
2887 using base = SgAsmDwarfConstruct;
2888 static constexpr char const * const name{"AsmDwarfLabel"};
2889 static constexpr unsigned long variant{106};
2890 static constexpr bool concrete{true};
2891 using subclasses_t = mp::List<>;
2892 using fields_t = mp::List<>;
2893};
2894template <> struct node_from_variant_t<106> { using type = SgAsmDwarfLabel; };
2895
2896// Class: AsmDwarfLexicalBlock
2897template <> struct describe_field_t<SgAsmDwarfLexicalBlock,SgAsmDwarfConstructList*,&SgAsmDwarfLexicalBlock::p_body> {
2900 static constexpr size_t position{0};
2901 static constexpr char const * const name{"body"};
2902 static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
2903 static constexpr bool traverse{true};
2904 static constexpr auto mbr_ptr{&SgAsmDwarfLexicalBlock::p_body};
2905 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2906 using bind = Desc<SgAsmDwarfLexicalBlock, SgAsmDwarfConstructList* SgAsmDwarfLexicalBlock::*, &SgAsmDwarfLexicalBlock::p_body>;
2907};
2910 using base = SgAsmDwarfConstruct;
2911 static constexpr char const * const name{"AsmDwarfLexicalBlock"};
2912 static constexpr unsigned long variant{107};
2913 static constexpr bool concrete{true};
2914 using subclasses_t = mp::List<>;
2916};
2917template <> struct node_from_variant_t<107> { using type = SgAsmDwarfLexicalBlock; };
2918
2919// Class: AsmDwarfLine
2920template <> struct describe_field_t<SgAsmDwarfLine,uint64_t,&SgAsmDwarfLine::p_address> {
2921 using parent = SgAsmDwarfLine;
2922 using field_type = uint64_t;
2923 static constexpr size_t position{0};
2924 static constexpr char const * const name{"address"};
2925 static constexpr char const * const typestr{"uint64_t"};
2926 static constexpr bool traverse{false};
2927 static constexpr auto mbr_ptr{&SgAsmDwarfLine::p_address};
2928 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2929 using bind = Desc<SgAsmDwarfLine, uint64_t SgAsmDwarfLine::*, &SgAsmDwarfLine::p_address>;
2930};
2931template <> struct describe_field_t<SgAsmDwarfLine,int,&SgAsmDwarfLine::p_file_id> {
2932 using parent = SgAsmDwarfLine;
2933 using field_type = int;
2934 static constexpr size_t position{1};
2935 static constexpr char const * const name{"file_id"};
2936 static constexpr char const * const typestr{"int"};
2937 static constexpr bool traverse{false};
2938 static constexpr auto mbr_ptr{&SgAsmDwarfLine::p_file_id};
2939 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2940 using bind = Desc<SgAsmDwarfLine, int SgAsmDwarfLine::*, &SgAsmDwarfLine::p_file_id>;
2941};
2942template <> struct describe_field_t<SgAsmDwarfLine,int,&SgAsmDwarfLine::p_line> {
2943 using parent = SgAsmDwarfLine;
2944 using field_type = int;
2945 static constexpr size_t position{2};
2946 static constexpr char const * const name{"line"};
2947 static constexpr char const * const typestr{"int"};
2948 static constexpr bool traverse{false};
2949 static constexpr auto mbr_ptr{&SgAsmDwarfLine::p_line};
2950 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2951 using bind = Desc<SgAsmDwarfLine, int SgAsmDwarfLine::*, &SgAsmDwarfLine::p_line>;
2952};
2953template <> struct describe_field_t<SgAsmDwarfLine,int,&SgAsmDwarfLine::p_column> {
2954 using parent = SgAsmDwarfLine;
2955 using field_type = int;
2956 static constexpr size_t position{3};
2957 static constexpr char const * const name{"column"};
2958 static constexpr char const * const typestr{"int"};
2959 static constexpr bool traverse{false};
2960 static constexpr auto mbr_ptr{&SgAsmDwarfLine::p_column};
2961 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2962 using bind = Desc<SgAsmDwarfLine, int SgAsmDwarfLine::*, &SgAsmDwarfLine::p_column>;
2963};
2964template <> struct describe_node_t<SgAsmDwarfLine> {
2965 using node = SgAsmDwarfLine;
2967 static constexpr char const * const name{"AsmDwarfLine"};
2968 static constexpr unsigned long variant{108};
2969 static constexpr bool concrete{true};
2970 using subclasses_t = mp::List<>;
2972};
2973template <> struct node_from_variant_t<108> { using type = SgAsmDwarfLine; };
2974
2975// Class: AsmDwarfLineList
2976template <> struct describe_field_t<SgAsmDwarfLineList,SgAsmDwarfLinePtrList,&SgAsmDwarfLineList::p_line_list> {
2977 using parent = SgAsmDwarfLineList;
2978 using field_type = SgAsmDwarfLinePtrList;
2979 static constexpr size_t position{0};
2980 static constexpr char const * const name{"line_list"};
2981 static constexpr char const * const typestr{"SgAsmDwarfLinePtrList"};
2982 static constexpr bool traverse{true};
2983 static constexpr auto mbr_ptr{&SgAsmDwarfLineList::p_line_list};
2984 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2985 using bind = Desc<SgAsmDwarfLineList, SgAsmDwarfLinePtrList SgAsmDwarfLineList::*, &SgAsmDwarfLineList::p_line_list>;
2986};
2988 using node = SgAsmDwarfLineList;
2990 static constexpr char const * const name{"AsmDwarfLineList"};
2991 static constexpr unsigned long variant{109};
2992 static constexpr bool concrete{true};
2993 using subclasses_t = mp::List<>;
2995};
2996template <> struct node_from_variant_t<109> { using type = SgAsmDwarfLineList; };
2997
2998// Class: AsmDwarfMacro
2999template <> struct describe_field_t<SgAsmDwarfMacro,std::string,&SgAsmDwarfMacro::p_macro_string> {
3000 using parent = SgAsmDwarfMacro;
3001 using field_type = std::string;
3002 static constexpr size_t position{0};
3003 static constexpr char const * const name{"macro_string"};
3004 static constexpr char const * const typestr{"std::string"};
3005 static constexpr bool traverse{false};
3006 static constexpr auto mbr_ptr{&SgAsmDwarfMacro::p_macro_string};
3007 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3008 using bind = Desc<SgAsmDwarfMacro, std::string SgAsmDwarfMacro::*, &SgAsmDwarfMacro::p_macro_string>;
3009};
3011 using node = SgAsmDwarfMacro;
3013 static constexpr char const * const name{"AsmDwarfMacro"};
3014 static constexpr unsigned long variant{110};
3015 static constexpr bool concrete{true};
3016 using subclasses_t = mp::List<>;
3018};
3019template <> struct node_from_variant_t<110> { using type = SgAsmDwarfMacro; };
3020
3021// Class: AsmDwarfMacroList
3022template <> struct describe_field_t<SgAsmDwarfMacroList,SgAsmDwarfMacroPtrList,&SgAsmDwarfMacroList::p_macro_list> {
3024 using field_type = SgAsmDwarfMacroPtrList;
3025 static constexpr size_t position{0};
3026 static constexpr char const * const name{"macro_list"};
3027 static constexpr char const * const typestr{"SgAsmDwarfMacroPtrList"};
3028 static constexpr bool traverse{true};
3029 static constexpr auto mbr_ptr{&SgAsmDwarfMacroList::p_macro_list};
3030 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3031 using bind = Desc<SgAsmDwarfMacroList, SgAsmDwarfMacroPtrList SgAsmDwarfMacroList::*, &SgAsmDwarfMacroList::p_macro_list>;
3032};
3034 using node = SgAsmDwarfMacroList;
3036 static constexpr char const * const name{"AsmDwarfMacroList"};
3037 static constexpr unsigned long variant{111};
3038 static constexpr bool concrete{true};
3039 using subclasses_t = mp::List<>;
3041};
3042template <> struct node_from_variant_t<111> { using type = SgAsmDwarfMacroList; };
3043
3044// Class: AsmDwarfMember
3046 using node = SgAsmDwarfMember;
3047 using base = SgAsmDwarfConstruct;
3048 static constexpr char const * const name{"AsmDwarfMember"};
3049 static constexpr unsigned long variant{112};
3050 static constexpr bool concrete{true};
3051 using subclasses_t = mp::List<>;
3052 using fields_t = mp::List<>;
3053};
3054template <> struct node_from_variant_t<112> { using type = SgAsmDwarfMember; };
3055
3056// Class: AsmDwarfModule
3058 using node = SgAsmDwarfModule;
3059 using base = SgAsmDwarfConstruct;
3060 static constexpr char const * const name{"AsmDwarfModule"};
3061 static constexpr unsigned long variant{113};
3062 static constexpr bool concrete{true};
3063 using subclasses_t = mp::List<>;
3064 using fields_t = mp::List<>;
3065};
3066template <> struct node_from_variant_t<113> { using type = SgAsmDwarfModule; };
3067
3068// Class: AsmDwarfMutableType
3071 using base = SgAsmDwarfConstruct;
3072 static constexpr char const * const name{"AsmDwarfMutableType"};
3073 static constexpr unsigned long variant{114};
3074 static constexpr bool concrete{true};
3075 using subclasses_t = mp::List<>;
3076 using fields_t = mp::List<>;
3077};
3078template <> struct node_from_variant_t<114> { using type = SgAsmDwarfMutableType; };
3079
3080// Class: AsmDwarfNamelist
3082 using node = SgAsmDwarfNamelist;
3083 using base = SgAsmDwarfConstruct;
3084 static constexpr char const * const name{"AsmDwarfNamelist"};
3085 static constexpr unsigned long variant{115};
3086 static constexpr bool concrete{true};
3087 using subclasses_t = mp::List<>;
3088 using fields_t = mp::List<>;
3089};
3090template <> struct node_from_variant_t<115> { using type = SgAsmDwarfNamelist; };
3091
3092// Class: AsmDwarfNamelistItem
3095 using base = SgAsmDwarfConstruct;
3096 static constexpr char const * const name{"AsmDwarfNamelistItem"};
3097 static constexpr unsigned long variant{116};
3098 static constexpr bool concrete{true};
3099 using subclasses_t = mp::List<>;
3100 using fields_t = mp::List<>;
3101};
3102template <> struct node_from_variant_t<116> { using type = SgAsmDwarfNamelistItem; };
3103
3104// Class: AsmDwarfNamespace
3105template <> struct describe_field_t<SgAsmDwarfNamespace,SgAsmDwarfConstructList*,&SgAsmDwarfNamespace::p_body> {
3108 static constexpr size_t position{0};
3109 static constexpr char const * const name{"body"};
3110 static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
3111 static constexpr bool traverse{true};
3112 static constexpr auto mbr_ptr{&SgAsmDwarfNamespace::p_body};
3113 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3114 using bind = Desc<SgAsmDwarfNamespace, SgAsmDwarfConstructList* SgAsmDwarfNamespace::*, &SgAsmDwarfNamespace::p_body>;
3115};
3117 using node = SgAsmDwarfNamespace;
3118 using base = SgAsmDwarfConstruct;
3119 static constexpr char const * const name{"AsmDwarfNamespace"};
3120 static constexpr unsigned long variant{117};
3121 static constexpr bool concrete{true};
3122 using subclasses_t = mp::List<>;
3124};
3125template <> struct node_from_variant_t<117> { using type = SgAsmDwarfNamespace; };
3126
3127// Class: AsmDwarfPackedType
3129 using node = SgAsmDwarfPackedType;
3130 using base = SgAsmDwarfConstruct;
3131 static constexpr char const * const name{"AsmDwarfPackedType"};
3132 static constexpr unsigned long variant{118};
3133 static constexpr bool concrete{true};
3134 using subclasses_t = mp::List<>;
3135 using fields_t = mp::List<>;
3136};
3137template <> struct node_from_variant_t<118> { using type = SgAsmDwarfPackedType; };
3138
3139// Class: AsmDwarfPartialUnit
3142 using base = SgAsmDwarfConstruct;
3143 static constexpr char const * const name{"AsmDwarfPartialUnit"};
3144 static constexpr unsigned long variant{119};
3145 static constexpr bool concrete{true};
3146 using subclasses_t = mp::List<>;
3147 using fields_t = mp::List<>;
3148};
3149template <> struct node_from_variant_t<119> { using type = SgAsmDwarfPartialUnit; };
3150
3151// Class: AsmDwarfPointerType
3154 using base = SgAsmDwarfConstruct;
3155 static constexpr char const * const name{"AsmDwarfPointerType"};
3156 static constexpr unsigned long variant{120};
3157 static constexpr bool concrete{true};
3158 using subclasses_t = mp::List<>;
3159 using fields_t = mp::List<>;
3160};
3161template <> struct node_from_variant_t<120> { using type = SgAsmDwarfPointerType; };
3162
3163// Class: AsmDwarfPtrToMemberType
3166 using base = SgAsmDwarfConstruct;
3167 static constexpr char const * const name{"AsmDwarfPtrToMemberType"};
3168 static constexpr unsigned long variant{121};
3169 static constexpr bool concrete{true};
3170 using subclasses_t = mp::List<>;
3171 using fields_t = mp::List<>;
3172};
3173template <> struct node_from_variant_t<121> { using type = SgAsmDwarfPtrToMemberType; };
3174
3175// Class: AsmDwarfReferenceType
3178 using base = SgAsmDwarfConstruct;
3179 static constexpr char const * const name{"AsmDwarfReferenceType"};
3180 static constexpr unsigned long variant{122};
3181 static constexpr bool concrete{true};
3182 using subclasses_t = mp::List<>;
3183 using fields_t = mp::List<>;
3184};
3185template <> struct node_from_variant_t<122> { using type = SgAsmDwarfReferenceType; };
3186
3187// Class: AsmDwarfRestrictType
3190 using base = SgAsmDwarfConstruct;
3191 static constexpr char const * const name{"AsmDwarfRestrictType"};
3192 static constexpr unsigned long variant{123};
3193 static constexpr bool concrete{true};
3194 using subclasses_t = mp::List<>;
3195 using fields_t = mp::List<>;
3196};
3197template <> struct node_from_variant_t<123> { using type = SgAsmDwarfRestrictType; };
3198
3199// Class: AsmDwarfSetType
3201 using node = SgAsmDwarfSetType;
3202 using base = SgAsmDwarfConstruct;
3203 static constexpr char const * const name{"AsmDwarfSetType"};
3204 static constexpr unsigned long variant{124};
3205 static constexpr bool concrete{true};
3206 using subclasses_t = mp::List<>;
3207 using fields_t = mp::List<>;
3208};
3209template <> struct node_from_variant_t<124> { using type = SgAsmDwarfSetType; };
3210
3211// Class: AsmDwarfSharedType
3213 using node = SgAsmDwarfSharedType;
3214 using base = SgAsmDwarfConstruct;
3215 static constexpr char const * const name{"AsmDwarfSharedType"};
3216 static constexpr unsigned long variant{125};
3217 static constexpr bool concrete{true};
3218 using subclasses_t = mp::List<>;
3219 using fields_t = mp::List<>;
3220};
3221template <> struct node_from_variant_t<125> { using type = SgAsmDwarfSharedType; };
3222
3223// Class: AsmDwarfStringType
3225 using node = SgAsmDwarfStringType;
3226 using base = SgAsmDwarfConstruct;
3227 static constexpr char const * const name{"AsmDwarfStringType"};
3228 static constexpr unsigned long variant{126};
3229 static constexpr bool concrete{true};
3230 using subclasses_t = mp::List<>;
3231 using fields_t = mp::List<>;
3232};
3233template <> struct node_from_variant_t<126> { using type = SgAsmDwarfStringType; };
3234
3235// Class: AsmDwarfStructureType
3236template <> struct describe_field_t<SgAsmDwarfStructureType,SgAsmDwarfConstructList*,&SgAsmDwarfStructureType::p_body> {
3239 static constexpr size_t position{0};
3240 static constexpr char const * const name{"body"};
3241 static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
3242 static constexpr bool traverse{true};
3243 static constexpr auto mbr_ptr{&SgAsmDwarfStructureType::p_body};
3244 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3245 using bind = Desc<SgAsmDwarfStructureType, SgAsmDwarfConstructList* SgAsmDwarfStructureType::*, &SgAsmDwarfStructureType::p_body>;
3246};
3249 using base = SgAsmDwarfConstruct;
3250 static constexpr char const * const name{"AsmDwarfStructureType"};
3251 static constexpr unsigned long variant{127};
3252 static constexpr bool concrete{true};
3253 using subclasses_t = mp::List<>;
3255};
3256template <> struct node_from_variant_t<127> { using type = SgAsmDwarfStructureType; };
3257
3258// Class: AsmDwarfSubprogram
3259template <> struct describe_field_t<SgAsmDwarfSubprogram,SgAsmDwarfConstructList*,&SgAsmDwarfSubprogram::p_body> {
3262 static constexpr size_t position{0};
3263 static constexpr char const * const name{"body"};
3264 static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
3265 static constexpr bool traverse{true};
3266 static constexpr auto mbr_ptr{&SgAsmDwarfSubprogram::p_body};
3267 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3268 using bind = Desc<SgAsmDwarfSubprogram, SgAsmDwarfConstructList* SgAsmDwarfSubprogram::*, &SgAsmDwarfSubprogram::p_body>;
3269};
3271 using node = SgAsmDwarfSubprogram;
3272 using base = SgAsmDwarfConstruct;
3273 static constexpr char const * const name{"AsmDwarfSubprogram"};
3274 static constexpr unsigned long variant{128};
3275 static constexpr bool concrete{true};
3276 using subclasses_t = mp::List<>;
3278};
3279template <> struct node_from_variant_t<128> { using type = SgAsmDwarfSubprogram; };
3280
3281// Class: AsmDwarfSubrangeType
3284 using base = SgAsmDwarfConstruct;
3285 static constexpr char const * const name{"AsmDwarfSubrangeType"};
3286 static constexpr unsigned long variant{129};
3287 static constexpr bool concrete{true};
3288 using subclasses_t = mp::List<>;
3289 using fields_t = mp::List<>;
3290};
3291template <> struct node_from_variant_t<129> { using type = SgAsmDwarfSubrangeType; };
3292
3293// Class: AsmDwarfSubroutineType
3294template <> struct describe_field_t<SgAsmDwarfSubroutineType,SgAsmDwarfConstructList*,&SgAsmDwarfSubroutineType::p_body> {
3297 static constexpr size_t position{0};
3298 static constexpr char const * const name{"body"};
3299 static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
3300 static constexpr bool traverse{true};
3301 static constexpr auto mbr_ptr{&SgAsmDwarfSubroutineType::p_body};
3302 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3303 using bind = Desc<SgAsmDwarfSubroutineType, SgAsmDwarfConstructList* SgAsmDwarfSubroutineType::*, &SgAsmDwarfSubroutineType::p_body>;
3304};
3307 using base = SgAsmDwarfConstruct;
3308 static constexpr char const * const name{"AsmDwarfSubroutineType"};
3309 static constexpr unsigned long variant{130};
3310 static constexpr bool concrete{true};
3311 using subclasses_t = mp::List<>;
3313};
3314template <> struct node_from_variant_t<130> { using type = SgAsmDwarfSubroutineType; };
3315
3316// Class: AsmDwarfTemplateTypeParameter
3319 using base = SgAsmDwarfConstruct;
3320 static constexpr char const * const name{"AsmDwarfTemplateTypeParameter"};
3321 static constexpr unsigned long variant{131};
3322 static constexpr bool concrete{true};
3323 using subclasses_t = mp::List<>;
3324 using fields_t = mp::List<>;
3325};
3326template <> struct node_from_variant_t<131> { using type = SgAsmDwarfTemplateTypeParameter; };
3327
3328// Class: AsmDwarfTemplateValueParameter
3331 using base = SgAsmDwarfConstruct;
3332 static constexpr char const * const name{"AsmDwarfTemplateValueParameter"};
3333 static constexpr unsigned long variant{132};
3334 static constexpr bool concrete{true};
3335 using subclasses_t = mp::List<>;
3336 using fields_t = mp::List<>;
3337};
3338template <> struct node_from_variant_t<132> { using type = SgAsmDwarfTemplateValueParameter; };
3339
3340// Class: AsmDwarfThrownType
3342 using node = SgAsmDwarfThrownType;
3343 using base = SgAsmDwarfConstruct;
3344 static constexpr char const * const name{"AsmDwarfThrownType"};
3345 static constexpr unsigned long variant{133};
3346 static constexpr bool concrete{true};
3347 using subclasses_t = mp::List<>;
3348 using fields_t = mp::List<>;
3349};
3350template <> struct node_from_variant_t<133> { using type = SgAsmDwarfThrownType; };
3351
3352// Class: AsmDwarfTryBlock
3354 using node = SgAsmDwarfTryBlock;
3355 using base = SgAsmDwarfConstruct;
3356 static constexpr char const * const name{"AsmDwarfTryBlock"};
3357 static constexpr unsigned long variant{134};
3358 static constexpr bool concrete{true};
3359 using subclasses_t = mp::List<>;
3360 using fields_t = mp::List<>;
3361};
3362template <> struct node_from_variant_t<134> { using type = SgAsmDwarfTryBlock; };
3363
3364// Class: AsmDwarfTypedef
3366 using node = SgAsmDwarfTypedef;
3367 using base = SgAsmDwarfConstruct;
3368 static constexpr char const * const name{"AsmDwarfTypedef"};
3369 static constexpr unsigned long variant{135};
3370 static constexpr bool concrete{true};
3371 using subclasses_t = mp::List<>;
3372 using fields_t = mp::List<>;
3373};
3374template <> struct node_from_variant_t<135> { using type = SgAsmDwarfTypedef; };
3375
3376// Class: AsmDwarfUnionType
3377template <> struct describe_field_t<SgAsmDwarfUnionType,SgAsmDwarfConstructList*,&SgAsmDwarfUnionType::p_body> {
3380 static constexpr size_t position{0};
3381 static constexpr char const * const name{"body"};
3382 static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
3383 static constexpr bool traverse{true};
3384 static constexpr auto mbr_ptr{&SgAsmDwarfUnionType::p_body};
3385 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3386 using bind = Desc<SgAsmDwarfUnionType, SgAsmDwarfConstructList* SgAsmDwarfUnionType::*, &SgAsmDwarfUnionType::p_body>;
3387};
3389 using node = SgAsmDwarfUnionType;
3390 using base = SgAsmDwarfConstruct;
3391 static constexpr char const * const name{"AsmDwarfUnionType"};
3392 static constexpr unsigned long variant{136};
3393 static constexpr bool concrete{true};
3394 using subclasses_t = mp::List<>;
3396};
3397template <> struct node_from_variant_t<136> { using type = SgAsmDwarfUnionType; };
3398
3399// Class: AsmDwarfUnknownConstruct
3402 using base = SgAsmDwarfConstruct;
3403 static constexpr char const * const name{"AsmDwarfUnknownConstruct"};
3404 static constexpr unsigned long variant{137};
3405 static constexpr bool concrete{true};
3406 using subclasses_t = mp::List<>;
3407 using fields_t = mp::List<>;
3408};
3409template <> struct node_from_variant_t<137> { using type = SgAsmDwarfUnknownConstruct; };
3410
3411// Class: AsmDwarfUnspecifiedParameters
3414 using base = SgAsmDwarfConstruct;
3415 static constexpr char const * const name{"AsmDwarfUnspecifiedParameters"};
3416 static constexpr unsigned long variant{138};
3417 static constexpr bool concrete{true};
3418 using subclasses_t = mp::List<>;
3419 using fields_t = mp::List<>;
3420};
3421template <> struct node_from_variant_t<138> { using type = SgAsmDwarfUnspecifiedParameters; };
3422
3423// Class: AsmDwarfUnspecifiedType
3426 using base = SgAsmDwarfConstruct;
3427 static constexpr char const * const name{"AsmDwarfUnspecifiedType"};
3428 static constexpr unsigned long variant{139};
3429 static constexpr bool concrete{true};
3430 using subclasses_t = mp::List<>;
3431 using fields_t = mp::List<>;
3432};
3433template <> struct node_from_variant_t<139> { using type = SgAsmDwarfUnspecifiedType; };
3434
3435// Class: AsmDwarfUpcRelaxedType
3438 using base = SgAsmDwarfConstruct;
3439 static constexpr char const * const name{"AsmDwarfUpcRelaxedType"};
3440 static constexpr unsigned long variant{140};
3441 static constexpr bool concrete{true};
3442 using subclasses_t = mp::List<>;
3443 using fields_t = mp::List<>;
3444};
3445template <> struct node_from_variant_t<140> { using type = SgAsmDwarfUpcRelaxedType; };
3446
3447// Class: AsmDwarfUpcSharedType
3450 using base = SgAsmDwarfConstruct;
3451 static constexpr char const * const name{"AsmDwarfUpcSharedType"};
3452 static constexpr unsigned long variant{141};
3453 static constexpr bool concrete{true};
3454 using subclasses_t = mp::List<>;
3455 using fields_t = mp::List<>;
3456};
3457template <> struct node_from_variant_t<141> { using type = SgAsmDwarfUpcSharedType; };
3458
3459// Class: AsmDwarfUpcStrictType
3462 using base = SgAsmDwarfConstruct;
3463 static constexpr char const * const name{"AsmDwarfUpcStrictType"};
3464 static constexpr unsigned long variant{142};
3465 static constexpr bool concrete{true};
3466 using subclasses_t = mp::List<>;
3467 using fields_t = mp::List<>;
3468};
3469template <> struct node_from_variant_t<142> { using type = SgAsmDwarfUpcStrictType; };
3470
3471// Class: AsmDwarfVariable
3473 using node = SgAsmDwarfVariable;
3474 using base = SgAsmDwarfConstruct;
3475 static constexpr char const * const name{"AsmDwarfVariable"};
3476 static constexpr unsigned long variant{143};
3477 static constexpr bool concrete{true};
3478 using subclasses_t = mp::List<>;
3479 using fields_t = mp::List<>;
3480};
3481template <> struct node_from_variant_t<143> { using type = SgAsmDwarfVariable; };
3482
3483// Class: AsmDwarfVariant
3485 using node = SgAsmDwarfVariant;
3486 using base = SgAsmDwarfConstruct;
3487 static constexpr char const * const name{"AsmDwarfVariant"};
3488 static constexpr unsigned long variant{144};
3489 static constexpr bool concrete{true};
3490 using subclasses_t = mp::List<>;
3491 using fields_t = mp::List<>;
3492};
3493template <> struct node_from_variant_t<144> { using type = SgAsmDwarfVariant; };
3494
3495// Class: AsmDwarfVariantPart
3498 using base = SgAsmDwarfConstruct;
3499 static constexpr char const * const name{"AsmDwarfVariantPart"};
3500 static constexpr unsigned long variant{145};
3501 static constexpr bool concrete{true};
3502 using subclasses_t = mp::List<>;
3503 using fields_t = mp::List<>;
3504};
3505template <> struct node_from_variant_t<145> { using type = SgAsmDwarfVariantPart; };
3506
3507// Class: AsmDwarfVolatileType
3510 using base = SgAsmDwarfConstruct;
3511 static constexpr char const * const name{"AsmDwarfVolatileType"};
3512 static constexpr unsigned long variant{146};
3513 static constexpr bool concrete{true};
3514 using subclasses_t = mp::List<>;
3515 using fields_t = mp::List<>;
3516};
3517template <> struct node_from_variant_t<146> { using type = SgAsmDwarfVolatileType; };
3518
3519// Class: AsmDwarfWithStmt
3521 using node = SgAsmDwarfWithStmt;
3522 using base = SgAsmDwarfConstruct;
3523 static constexpr char const * const name{"AsmDwarfWithStmt"};
3524 static constexpr unsigned long variant{147};
3525 static constexpr bool concrete{true};
3526 using subclasses_t = mp::List<>;
3527 using fields_t = mp::List<>;
3528};
3529template <> struct node_from_variant_t<147> { using type = SgAsmDwarfWithStmt; };
3530
3531// Class: AsmElfDynamicEntry
3532template <> struct describe_field_t<SgAsmElfDynamicEntry,SgAsmElfDynamicEntry::EntryType,&SgAsmElfDynamicEntry::p_d_tag> {
3534 using field_type = SgAsmElfDynamicEntry::EntryType;
3535 static constexpr size_t position{0};
3536 static constexpr char const * const name{"d_tag"};
3537 static constexpr char const * const typestr{"SgAsmElfDynamicEntry::EntryType"};
3538 static constexpr bool traverse{false};
3539 static constexpr auto mbr_ptr{&SgAsmElfDynamicEntry::p_d_tag};
3540 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3541 using bind = Desc<SgAsmElfDynamicEntry, SgAsmElfDynamicEntry::EntryType SgAsmElfDynamicEntry::*, &SgAsmElfDynamicEntry::p_d_tag>;
3542};
3543template <> struct describe_field_t<SgAsmElfDynamicEntry,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmElfDynamicEntry::p_d_val> {
3546 static constexpr size_t position{1};
3547 static constexpr char const * const name{"d_val"};
3548 static constexpr char const * const typestr{"Rose::BinaryAnalysis::RelativeVirtualAddress"};
3549 static constexpr bool traverse{false};
3550 static constexpr auto mbr_ptr{&SgAsmElfDynamicEntry::p_d_val};
3551 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3552 using bind = Desc<SgAsmElfDynamicEntry, Rose::BinaryAnalysis::RelativeVirtualAddress SgAsmElfDynamicEntry::*, &SgAsmElfDynamicEntry::p_d_val>;
3553};
3554template <> struct describe_field_t<SgAsmElfDynamicEntry,SgAsmGenericString*,&SgAsmElfDynamicEntry::p_name> {
3557 static constexpr size_t position{2};
3558 static constexpr char const * const name{"name"};
3559 static constexpr char const * const typestr{"SgAsmGenericString*"};
3560 static constexpr bool traverse{true};
3561 static constexpr auto mbr_ptr{&SgAsmElfDynamicEntry::p_name};
3562 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3563 using bind = Desc<SgAsmElfDynamicEntry, SgAsmGenericString* SgAsmElfDynamicEntry::*, &SgAsmElfDynamicEntry::p_name>;
3564};
3565template <> struct describe_field_t<SgAsmElfDynamicEntry,SgUnsignedCharList,&SgAsmElfDynamicEntry::p_extra> {
3567 using field_type = SgUnsignedCharList;
3568 static constexpr size_t position{3};
3569 static constexpr char const * const name{"extra"};
3570 static constexpr char const * const typestr{"SgUnsignedCharList"};
3571 static constexpr bool traverse{false};
3572 static constexpr auto mbr_ptr{&SgAsmElfDynamicEntry::p_extra};
3573 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3574 using bind = Desc<SgAsmElfDynamicEntry, SgUnsignedCharList SgAsmElfDynamicEntry::*, &SgAsmElfDynamicEntry::p_extra>;
3575};
3585template <> struct node_from_variant_t<148> { using type = SgAsmElfDynamicEntry; };
3586
3587// Class: AsmElfDynamicEntryList
3588template <> struct describe_field_t<SgAsmElfDynamicEntryList,SgAsmElfDynamicEntryPtrList,&SgAsmElfDynamicEntryList::p_entries> {
3590 using field_type = SgAsmElfDynamicEntryPtrList;
3591 static constexpr size_t position{0};
3592 static constexpr char const * const name{"entries"};
3593 static constexpr char const * const typestr{"SgAsmElfDynamicEntryPtrList"};
3594 static constexpr bool traverse{false};
3595 static constexpr auto mbr_ptr{&SgAsmElfDynamicEntryList::p_entries};
3596 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3597 using bind = Desc<SgAsmElfDynamicEntryList, SgAsmElfDynamicEntryPtrList SgAsmElfDynamicEntryList::*, &SgAsmElfDynamicEntryList::p_entries>;
3598};
3602 static constexpr char const * const name{"AsmElfDynamicEntryList"};
3603 static constexpr unsigned long variant{149};
3604 static constexpr bool concrete{true};
3605 using subclasses_t = mp::List<>;
3607};
3608template <> struct node_from_variant_t<149> { using type = SgAsmElfDynamicEntryList; };
3609
3610// Class: AsmElfDynamicSection
3611template <> struct describe_field_t<SgAsmElfDynamicSection,SgAsmElfDynamicEntryList*,&SgAsmElfDynamicSection::p_entries> {
3614 static constexpr size_t position{0};
3615 static constexpr char const * const name{"entries"};
3616 static constexpr char const * const typestr{"SgAsmElfDynamicEntryList*"};
3617 static constexpr bool traverse{true};
3618 static constexpr auto mbr_ptr{&SgAsmElfDynamicSection::p_entries};
3619 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3620 using bind = Desc<SgAsmElfDynamicSection, SgAsmElfDynamicEntryList* SgAsmElfDynamicSection::*, &SgAsmElfDynamicSection::p_entries>;
3621};
3624 using base = SgAsmElfSection;
3625 static constexpr char const * const name{"AsmElfDynamicSection"};
3626 static constexpr unsigned long variant{150};
3627 static constexpr bool concrete{true};
3628 using subclasses_t = mp::List<>;
3630};
3631template <> struct node_from_variant_t<150> { using type = SgAsmElfDynamicSection; };
3632
3633// Class: AsmElfEHFrameEntryCI
3634template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,int,&SgAsmElfEHFrameEntryCI::p_version> {
3636 using field_type = int;
3637 static constexpr size_t position{0};
3638 static constexpr char const * const name{"version"};
3639 static constexpr char const * const typestr{"int"};
3640 static constexpr bool traverse{false};
3641 static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_version};
3642 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3643 using bind = Desc<SgAsmElfEHFrameEntryCI, int SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_version>;
3644};
3645template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,std::string,&SgAsmElfEHFrameEntryCI::p_augmentation_string> {
3647 using field_type = std::string;
3648 static constexpr size_t position{1};
3649 static constexpr char const * const name{"augmentation_string"};
3650 static constexpr char const * const typestr{"std::string"};
3651 static constexpr bool traverse{false};
3652 static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_augmentation_string};
3653 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3654 using bind = Desc<SgAsmElfEHFrameEntryCI, std::string SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_augmentation_string>;
3655};
3656template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,uint64_t,&SgAsmElfEHFrameEntryCI::p_eh_data> {
3658 using field_type = uint64_t;
3659 static constexpr size_t position{2};
3660 static constexpr char const * const name{"eh_data"};
3661 static constexpr char const * const typestr{"uint64_t"};
3662 static constexpr bool traverse{false};
3663 static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_eh_data};
3664 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3665 using bind = Desc<SgAsmElfEHFrameEntryCI, uint64_t SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_eh_data>;
3666};
3667template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,uint64_t,&SgAsmElfEHFrameEntryCI::p_code_alignment_factor> {
3669 using field_type = uint64_t;
3670 static constexpr size_t position{3};
3671 static constexpr char const * const name{"code_alignment_factor"};
3672 static constexpr char const * const typestr{"uint64_t"};
3673 static constexpr bool traverse{false};
3674 static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_code_alignment_factor};
3675 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3676 using bind = Desc<SgAsmElfEHFrameEntryCI, uint64_t SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_code_alignment_factor>;
3677};
3678template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,int64_t,&SgAsmElfEHFrameEntryCI::p_data_alignment_factor> {
3680 using field_type = int64_t;
3681 static constexpr size_t position{4};
3682 static constexpr char const * const name{"data_alignment_factor"};
3683 static constexpr char const * const typestr{"int64_t"};
3684 static constexpr bool traverse{false};
3685 static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_data_alignment_factor};
3686 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3687 using bind = Desc<SgAsmElfEHFrameEntryCI, int64_t SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_data_alignment_factor>;
3688};
3689template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,uint64_t,&SgAsmElfEHFrameEntryCI::p_augmentation_data_length> {
3691 using field_type = uint64_t;
3692 static constexpr size_t position{5};
3693 static constexpr char const * const name{"augmentation_data_length"};
3694 static constexpr char const * const typestr{"uint64_t"};
3695 static constexpr bool traverse{false};
3696 static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_augmentation_data_length};
3697 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3698 using bind = Desc<SgAsmElfEHFrameEntryCI, uint64_t SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_augmentation_data_length>;
3699};
3700template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,int,&SgAsmElfEHFrameEntryCI::p_lsda_encoding> {
3702 using field_type = int;
3703 static constexpr size_t position{6};
3704 static constexpr char const * const name{"lsda_encoding"};
3705 static constexpr char const * const typestr{"int"};
3706 static constexpr bool traverse{false};
3707 static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_lsda_encoding};
3708 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3709 using bind = Desc<SgAsmElfEHFrameEntryCI, int SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_lsda_encoding>;
3710};
3711template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,int,&SgAsmElfEHFrameEntryCI::p_prh_encoding> {
3713 using field_type = int;
3714 static constexpr size_t position{7};
3715 static constexpr char const * const name{"prh_encoding"};
3716 static constexpr char const * const typestr{"int"};
3717 static constexpr bool traverse{false};
3718 static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_prh_encoding};
3719 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3720 using bind = Desc<SgAsmElfEHFrameEntryCI, int SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_prh_encoding>;
3721};
3722template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,unsigned,&SgAsmElfEHFrameEntryCI::p_prh_arg> {
3724 using field_type = unsigned;
3725 static constexpr size_t position{8};
3726 static constexpr char const * const name{"prh_arg"};
3727 static constexpr char const * const typestr{"unsigned"};
3728 static constexpr bool traverse{false};
3729 static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_prh_arg};
3730 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3731 using bind = Desc<SgAsmElfEHFrameEntryCI, unsigned SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_prh_arg>;
3732};
3733template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,Rose::BinaryAnalysis::Address,&SgAsmElfEHFrameEntryCI::p_prh_addr> {
3735 using field_type = Rose::BinaryAnalysis::Address;
3736 static constexpr size_t position{9};
3737 static constexpr char const * const name{"prh_addr"};
3738 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
3739 static constexpr bool traverse{false};
3740 static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_prh_addr};
3741 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3742 using bind = Desc<SgAsmElfEHFrameEntryCI, Rose::BinaryAnalysis::Address SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_prh_addr>;
3743};
3744template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,int,&SgAsmElfEHFrameEntryCI::p_addr_encoding> {
3746 using field_type = int;
3747 static constexpr size_t position{10};
3748 static constexpr char const * const name{"addr_encoding"};
3749 static constexpr char const * const typestr{"int"};
3750 static constexpr bool traverse{false};
3751 static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_addr_encoding};
3752 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3753 using bind = Desc<SgAsmElfEHFrameEntryCI, int SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_addr_encoding>;
3754};
3755template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,bool,&SgAsmElfEHFrameEntryCI::p_sig_frame> {
3757 using field_type = bool;
3758 static constexpr size_t position{11};
3759 static constexpr char const * const name{"sig_frame"};
3760 static constexpr char const * const typestr{"bool"};
3761 static constexpr bool traverse{false};
3762 static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_sig_frame};
3763 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3764 using bind = Desc<SgAsmElfEHFrameEntryCI, bool SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_sig_frame>;
3765};
3766template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,SgUnsignedCharList,&SgAsmElfEHFrameEntryCI::p_instructions> {
3768 using field_type = SgUnsignedCharList;
3769 static constexpr size_t position{12};
3770 static constexpr char const * const name{"instructions"};
3771 static constexpr char const * const typestr{"SgUnsignedCharList"};
3772 static constexpr bool traverse{false};
3773 static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_instructions};
3774 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3775 using bind = Desc<SgAsmElfEHFrameEntryCI, SgUnsignedCharList SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_instructions>;
3776};
3777template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,SgAsmElfEHFrameEntryFDList*,&SgAsmElfEHFrameEntryCI::p_fd_entries> {
3780 static constexpr size_t position{13};
3781 static constexpr char const * const name{"fd_entries"};
3782 static constexpr char const * const typestr{"SgAsmElfEHFrameEntryFDList*"};
3783 static constexpr bool traverse{true};
3784 static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_fd_entries};
3785 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3786 using bind = Desc<SgAsmElfEHFrameEntryCI, SgAsmElfEHFrameEntryFDList* SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_fd_entries>;
3787};
3791 static constexpr char const * const name{"AsmElfEHFrameEntryCI"};
3792 static constexpr unsigned long variant{151};
3793 static constexpr bool concrete{true};
3794 using subclasses_t = mp::List<>;
3796};
3797template <> struct node_from_variant_t<151> { using type = SgAsmElfEHFrameEntryCI; };
3798
3799// Class: AsmElfEHFrameEntryCIList
3800template <> struct describe_field_t<SgAsmElfEHFrameEntryCIList,SgAsmElfEHFrameEntryCIPtrList,&SgAsmElfEHFrameEntryCIList::p_entries> {
3802 using field_type = SgAsmElfEHFrameEntryCIPtrList;
3803 static constexpr size_t position{0};
3804 static constexpr char const * const name{"entries"};
3805 static constexpr char const * const typestr{"SgAsmElfEHFrameEntryCIPtrList"};
3806 static constexpr bool traverse{false};
3807 static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCIList::p_entries};
3808 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3809 using bind = Desc<SgAsmElfEHFrameEntryCIList, SgAsmElfEHFrameEntryCIPtrList SgAsmElfEHFrameEntryCIList::*, &SgAsmElfEHFrameEntryCIList::p_entries>;
3810};
3814 static constexpr char const * const name{"AsmElfEHFrameEntryCIList"};
3815 static constexpr unsigned long variant{152};
3816 static constexpr bool concrete{true};
3817 using subclasses_t = mp::List<>;
3819};
3820template <> struct node_from_variant_t<152> { using type = SgAsmElfEHFrameEntryCIList; };
3821
3822// Class: AsmElfEHFrameEntryFD
3823template <> struct describe_field_t<SgAsmElfEHFrameEntryFD,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmElfEHFrameEntryFD::p_begin_rva> {
3826 static constexpr size_t position{0};
3827 static constexpr char const * const name{"begin_rva"};
3828 static constexpr char const * const typestr{"Rose::BinaryAnalysis::RelativeVirtualAddress"};
3829 static constexpr bool traverse{false};
3830 static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryFD::p_begin_rva};
3831 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3832 using bind = Desc<SgAsmElfEHFrameEntryFD, Rose::BinaryAnalysis::RelativeVirtualAddress SgAsmElfEHFrameEntryFD::*, &SgAsmElfEHFrameEntryFD::p_begin_rva>;
3833};
3834template <> struct describe_field_t<SgAsmElfEHFrameEntryFD,Rose::BinaryAnalysis::Address,&SgAsmElfEHFrameEntryFD::p_size> {
3836 using field_type = Rose::BinaryAnalysis::Address;
3837 static constexpr size_t position{1};
3838 static constexpr char const * const name{"size"};
3839 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
3840 static constexpr bool traverse{false};
3841 static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryFD::p_size};
3842 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3843 using bind = Desc<SgAsmElfEHFrameEntryFD, Rose::BinaryAnalysis::Address SgAsmElfEHFrameEntryFD::*, &SgAsmElfEHFrameEntryFD::p_size>;
3844};
3845template <> struct describe_field_t<SgAsmElfEHFrameEntryFD,SgUnsignedCharList,&SgAsmElfEHFrameEntryFD::p_augmentation_data> {
3847 using field_type = SgUnsignedCharList;
3848 static constexpr size_t position{2};
3849 static constexpr char const * const name{"augmentation_data"};
3850 static constexpr char const * const typestr{"SgUnsignedCharList"};
3851 static constexpr bool traverse{false};
3852 static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryFD::p_augmentation_data};
3853 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3854 using bind = Desc<SgAsmElfEHFrameEntryFD, SgUnsignedCharList SgAsmElfEHFrameEntryFD::*, &SgAsmElfEHFrameEntryFD::p_augmentation_data>;
3855};
3856template <> struct describe_field_t<SgAsmElfEHFrameEntryFD,SgUnsignedCharList,&SgAsmElfEHFrameEntryFD::p_instructions> {
3858 using field_type = SgUnsignedCharList;
3859 static constexpr size_t position{3};
3860 static constexpr char const * const name{"instructions"};
3861 static constexpr char const * const typestr{"SgUnsignedCharList"};
3862 static constexpr bool traverse{false};
3863 static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryFD::p_instructions};
3864 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3865 using bind = Desc<SgAsmElfEHFrameEntryFD, SgUnsignedCharList SgAsmElfEHFrameEntryFD::*, &SgAsmElfEHFrameEntryFD::p_instructions>;
3866};
3876template <> struct node_from_variant_t<153> { using type = SgAsmElfEHFrameEntryFD; };
3877
3878// Class: AsmElfEHFrameEntryFDList
3879template <> struct describe_field_t<SgAsmElfEHFrameEntryFDList,SgAsmElfEHFrameEntryFDPtrList,&SgAsmElfEHFrameEntryFDList::p_entries> {
3881 using field_type = SgAsmElfEHFrameEntryFDPtrList;
3882 static constexpr size_t position{0};
3883 static constexpr char const * const name{"entries"};
3884 static constexpr char const * const typestr{"SgAsmElfEHFrameEntryFDPtrList"};
3885 static constexpr bool traverse{false};
3886 static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryFDList::p_entries};
3887 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3888 using bind = Desc<SgAsmElfEHFrameEntryFDList, SgAsmElfEHFrameEntryFDPtrList SgAsmElfEHFrameEntryFDList::*, &SgAsmElfEHFrameEntryFDList::p_entries>;
3889};
3893 static constexpr char const * const name{"AsmElfEHFrameEntryFDList"};
3894 static constexpr unsigned long variant{154};
3895 static constexpr bool concrete{true};
3896 using subclasses_t = mp::List<>;
3898};
3899template <> struct node_from_variant_t<154> { using type = SgAsmElfEHFrameEntryFDList; };
3900
3901// Class: AsmElfEHFrameSection
3902template <> struct describe_field_t<SgAsmElfEHFrameSection,SgAsmElfEHFrameEntryCIList*,&SgAsmElfEHFrameSection::p_ci_entries> {
3905 static constexpr size_t position{0};
3906 static constexpr char const * const name{"ci_entries"};
3907 static constexpr char const * const typestr{"SgAsmElfEHFrameEntryCIList*"};
3908 static constexpr bool traverse{true};
3909 static constexpr auto mbr_ptr{&SgAsmElfEHFrameSection::p_ci_entries};
3910 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3911 using bind = Desc<SgAsmElfEHFrameSection, SgAsmElfEHFrameEntryCIList* SgAsmElfEHFrameSection::*, &SgAsmElfEHFrameSection::p_ci_entries>;
3912};
3915 using base = SgAsmElfSection;
3916 static constexpr char const * const name{"AsmElfEHFrameSection"};
3917 static constexpr unsigned long variant{155};
3918 static constexpr bool concrete{true};
3919 using subclasses_t = mp::List<>;
3921};
3922template <> struct node_from_variant_t<155> { using type = SgAsmElfEHFrameSection; };
3923
3924// Class: AsmElfFileHeader
3925template <> struct describe_field_t<SgAsmElfFileHeader,unsigned char,&SgAsmElfFileHeader::p_e_ident_file_class> {
3926 using parent = SgAsmElfFileHeader;
3927 using field_type = unsigned char;
3928 static constexpr size_t position{0};
3929 static constexpr char const * const name{"e_ident_file_class"};
3930 static constexpr char const * const typestr{"unsigned char"};
3931 static constexpr bool traverse{false};
3932 static constexpr auto mbr_ptr{&SgAsmElfFileHeader::p_e_ident_file_class};
3933 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3934 using bind = Desc<SgAsmElfFileHeader, unsigned char SgAsmElfFileHeader::*, &SgAsmElfFileHeader::p_e_ident_file_class>;
3935};
3936template <> struct describe_field_t<SgAsmElfFileHeader,unsigned char,&SgAsmElfFileHeader::p_e_ident_data_encoding> {
3937 using parent = SgAsmElfFileHeader;
3938 using field_type = unsigned char;
3939 static constexpr size_t position{1};
3940 static constexpr char const * const name{"e_ident_data_encoding"};
3941 static constexpr char const * const typestr{"unsigned char"};
3942 static constexpr bool traverse{false};
3943 static constexpr auto mbr_ptr{&SgAsmElfFileHeader::p_e_ident_data_encoding};
3944 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3945 using bind = Desc<SgAsmElfFileHeader, unsigned char SgAsmElfFileHeader::*, &SgAsmElfFileHeader::p_e_ident_data_encoding>;
3946};
3947template <> struct describe_field_t<SgAsmElfFileHeader,unsigned char,&SgAsmElfFileHeader::p_e_ident_file_version> {
3948 using parent = SgAsmElfFileHeader;
3949 using field_type = unsigned char;
3950 static constexpr size_t position{2};
3951 static constexpr char const * const name{"e_ident_file_version"};
3952 static constexpr char const * const typestr{"unsigned char"};
3953 static constexpr bool traverse{false};
3954 static constexpr auto mbr_ptr{&SgAsmElfFileHeader::p_e_ident_file_version};
3955 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3956 using bind = Desc<SgAsmElfFileHeader, unsigned char SgAsmElfFileHeader::*, &SgAsmElfFileHeader::p_e_ident_file_version>;
3957};
3958template <> struct describe_field_t<SgAsmElfFileHeader,SgUnsignedCharList,&SgAsmElfFileHeader::p_e_ident_padding> {
3959 using parent = SgAsmElfFileHeader;
3960 using field_type = SgUnsignedCharList;
3961 static constexpr size_t position{3};
3962 static constexpr char const * const name{"e_ident_padding"};
3963 static constexpr char const * const typestr{"SgUnsignedCharList"};
3964 static constexpr bool traverse{false};
3965 static constexpr auto mbr_ptr{&SgAsmElfFileHeader::p_e_ident_padding};
3966 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3967 using bind = Desc<SgAsmElfFileHeader, SgUnsignedCharList SgAsmElfFileHeader::*, &SgAsmElfFileHeader::p_e_ident_padding>;
3968};
3969template <> struct describe_field_t<SgAsmElfFileHeader,unsigned long,&SgAsmElfFileHeader::p_e_type> {
3970 using parent = SgAsmElfFileHeader;
3971 using field_type = unsigned long;
3972 static constexpr size_t position{4};
3973 static constexpr char const * const name{"e_type"};
3974 static constexpr char const * const typestr{"unsigned long"};
3975 static constexpr bool traverse{false};
3976 static constexpr auto mbr_ptr{&SgAsmElfFileHeader::p_e_type};
3977 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3978 using bind = Desc<SgAsmElfFileHeader, unsigned long SgAsmElfFileHeader::*, &SgAsmElfFileHeader::p_e_type>;
3979};
3980template <> struct describe_field_t<SgAsmElfFileHeader,unsigned long,&SgAsmElfFileHeader::p_e_machine> {
3981 using parent = SgAsmElfFileHeader;
3982 using field_type = unsigned long;
3983 static constexpr size_t position{5};
3984 static constexpr char const * const name{"e_machine"};
3985 static constexpr char const * const typestr{"unsigned long"};
3986 static constexpr bool traverse{false};
3987 static constexpr auto mbr_ptr{&SgAsmElfFileHeader::p_e_machine};
3988 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3989 using bind = Desc<SgAsmElfFileHeader, unsigned long SgAsmElfFileHeader::*, &SgAsmElfFileHeader::p_e_machine>;
3990};
3991template <> struct describe_field_t<SgAsmElfFileHeader,unsigned long,&SgAsmElfFileHeader::p_e_flags> {
3992 using parent = SgAsmElfFileHeader;
3993 using field_type = unsigned long;
3994 static constexpr size_t position{6};
3995 static constexpr char const * const name{"e_flags"};
3996 static constexpr char const * const typestr{"unsigned long"};
3997 static constexpr bool traverse{false};
3998 static constexpr auto mbr_ptr{&SgAsmElfFileHeader::p_e_flags};
3999 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4000 using bind = Desc<SgAsmElfFileHeader, unsigned long SgAsmElfFileHeader::*, &SgAsmElfFileHeader::p_e_flags>;
4001};
4002template <> struct describe_field_t<SgAsmElfFileHeader,unsigned long,&SgAsmElfFileHeader::p_e_ehsize> {
4003 using parent = SgAsmElfFileHeader;
4004 using field_type = unsigned long;
4005 static constexpr size_t position{7};
4006 static constexpr char const * const name{"e_ehsize"};
4007 static constexpr char const * const typestr{"unsigned long"};
4008 static constexpr bool traverse{false};
4009 static constexpr auto mbr_ptr{&SgAsmElfFileHeader::p_e_ehsize};
4010 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4011 using bind = Desc<SgAsmElfFileHeader, unsigned long SgAsmElfFileHeader::*, &SgAsmElfFileHeader::p_e_ehsize>;
4012};
4013template <> struct describe_field_t<SgAsmElfFileHeader,unsigned long,&SgAsmElfFileHeader::p_phextrasz> {
4014 using parent = SgAsmElfFileHeader;
4015 using field_type = unsigned long;
4016 static constexpr size_t position{8};
4017 static constexpr char const * const name{"phextrasz"};
4018 static constexpr char const * const typestr{"unsigned long"};
4019 static constexpr bool traverse{false};
4020 static constexpr auto mbr_ptr{&SgAsmElfFileHeader::p_phextrasz};
4021 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4022 using bind = Desc<SgAsmElfFileHeader, unsigned long SgAsmElfFileHeader::*, &SgAsmElfFileHeader::p_phextrasz>;
4023};
4024template <> struct describe_field_t<SgAsmElfFileHeader,unsigned long,&SgAsmElfFileHeader::p_e_phnum> {
4025 using parent = SgAsmElfFileHeader;
4026 using field_type = unsigned long;
4027 static constexpr size_t position{9};
4028 static constexpr char const * const name{"e_phnum"};
4029 static constexpr char const * const typestr{"unsigned long"};
4030 static constexpr bool traverse{false};
4031 static constexpr auto mbr_ptr{&SgAsmElfFileHeader::p_e_phnum};
4032 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4033 using bind = Desc<SgAsmElfFileHeader, unsigned long SgAsmElfFileHeader::*, &SgAsmElfFileHeader::p_e_phnum>;
4034};
4035template <> struct describe_field_t<SgAsmElfFileHeader,unsigned long,&SgAsmElfFileHeader::p_shextrasz> {
4036 using parent = SgAsmElfFileHeader;
4037 using field_type = unsigned long;
4038 static constexpr size_t position{10};
4039 static constexpr char const * const name{"shextrasz"};
4040 static constexpr char const * const typestr{"unsigned long"};
4041 static constexpr bool traverse{false};
4042 static constexpr auto mbr_ptr{&SgAsmElfFileHeader::p_shextrasz};
4043 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4044 using bind = Desc<SgAsmElfFileHeader, unsigned long SgAsmElfFileHeader::*, &SgAsmElfFileHeader::p_shextrasz>;
4045};
4046template <> struct describe_field_t<SgAsmElfFileHeader,unsigned long,&SgAsmElfFileHeader::p_e_shnum> {
4047 using parent = SgAsmElfFileHeader;
4048 using field_type = unsigned long;
4049 static constexpr size_t position{11};
4050 static constexpr char const * const name{"e_shnum"};
4051 static constexpr char const * const typestr{"unsigned long"};
4052 static constexpr bool traverse{false};
4053 static constexpr auto mbr_ptr{&SgAsmElfFileHeader::p_e_shnum};
4054 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4055 using bind = Desc<SgAsmElfFileHeader, unsigned long SgAsmElfFileHeader::*, &SgAsmElfFileHeader::p_e_shnum>;
4056};
4057template <> struct describe_field_t<SgAsmElfFileHeader,unsigned long,&SgAsmElfFileHeader::p_e_shstrndx> {
4058 using parent = SgAsmElfFileHeader;
4059 using field_type = unsigned long;
4060 static constexpr size_t position{12};
4061 static constexpr char const * const name{"e_shstrndx"};
4062 static constexpr char const * const typestr{"unsigned long"};
4063 static constexpr bool traverse{false};
4064 static constexpr auto mbr_ptr{&SgAsmElfFileHeader::p_e_shstrndx};
4065 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4066 using bind = Desc<SgAsmElfFileHeader, unsigned long SgAsmElfFileHeader::*, &SgAsmElfFileHeader::p_e_shstrndx>;
4067};
4068template <> struct describe_field_t<SgAsmElfFileHeader,SgAsmElfSectionTable*,&SgAsmElfFileHeader::p_sectionTable> {
4069 using parent = SgAsmElfFileHeader;
4071 static constexpr size_t position{13};
4072 static constexpr char const * const name{"sectionTable"};
4073 static constexpr char const * const typestr{"SgAsmElfSectionTable*"};
4074 static constexpr bool traverse{false};
4075 static constexpr auto mbr_ptr{&SgAsmElfFileHeader::p_sectionTable};
4076 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4077 using bind = Desc<SgAsmElfFileHeader, SgAsmElfSectionTable* SgAsmElfFileHeader::*, &SgAsmElfFileHeader::p_sectionTable>;
4078};
4079template <> struct describe_field_t<SgAsmElfFileHeader,SgAsmElfSegmentTable*,&SgAsmElfFileHeader::p_segmentTable> {
4080 using parent = SgAsmElfFileHeader;
4082 static constexpr size_t position{14};
4083 static constexpr char const * const name{"segmentTable"};
4084 static constexpr char const * const typestr{"SgAsmElfSegmentTable*"};
4085 static constexpr bool traverse{false};
4086 static constexpr auto mbr_ptr{&SgAsmElfFileHeader::p_segmentTable};
4087 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4088 using bind = Desc<SgAsmElfFileHeader, SgAsmElfSegmentTable* SgAsmElfFileHeader::*, &SgAsmElfFileHeader::p_segmentTable>;
4089};
4091 using node = SgAsmElfFileHeader;
4092 using base = SgAsmGenericHeader;
4093 static constexpr char const * const name{"AsmElfFileHeader"};
4094 static constexpr unsigned long variant{156};
4095 static constexpr bool concrete{true};
4096 using subclasses_t = mp::List<>;
4098};
4099template <> struct node_from_variant_t<156> { using type = SgAsmElfFileHeader; };
4100
4101// Class: AsmElfNoteEntry
4102template <> struct describe_field_t<SgAsmElfNoteEntry,unsigned,&SgAsmElfNoteEntry::p_type> {
4103 using parent = SgAsmElfNoteEntry;
4104 using field_type = unsigned;
4105 static constexpr size_t position{0};
4106 static constexpr char const * const name{"type"};
4107 static constexpr char const * const typestr{"unsigned"};
4108 static constexpr bool traverse{false};
4109 static constexpr auto mbr_ptr{&SgAsmElfNoteEntry::p_type};
4110 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4111 using bind = Desc<SgAsmElfNoteEntry, unsigned SgAsmElfNoteEntry::*, &SgAsmElfNoteEntry::p_type>;
4112};
4113template <> struct describe_field_t<SgAsmElfNoteEntry,SgAsmGenericString*,&SgAsmElfNoteEntry::p_name> {
4114 using parent = SgAsmElfNoteEntry;
4116 static constexpr size_t position{1};
4117 static constexpr char const * const name{"name"};
4118 static constexpr char const * const typestr{"SgAsmGenericString*"};
4119 static constexpr bool traverse{true};
4120 static constexpr auto mbr_ptr{&SgAsmElfNoteEntry::p_name};
4121 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4122 using bind = Desc<SgAsmElfNoteEntry, SgAsmGenericString* SgAsmElfNoteEntry::*, &SgAsmElfNoteEntry::p_name>;
4123};
4124template <> struct describe_field_t<SgAsmElfNoteEntry,SgUnsignedCharList,&SgAsmElfNoteEntry::p_payload> {
4125 using parent = SgAsmElfNoteEntry;
4126 using field_type = SgUnsignedCharList;
4127 static constexpr size_t position{2};
4128 static constexpr char const * const name{"payload"};
4129 static constexpr char const * const typestr{"SgUnsignedCharList"};
4130 static constexpr bool traverse{false};
4131 static constexpr auto mbr_ptr{&SgAsmElfNoteEntry::p_payload};
4132 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4133 using bind = Desc<SgAsmElfNoteEntry, SgUnsignedCharList SgAsmElfNoteEntry::*, &SgAsmElfNoteEntry::p_payload>;
4134};
4136 using node = SgAsmElfNoteEntry;
4138 static constexpr char const * const name{"AsmElfNoteEntry"};
4139 static constexpr unsigned long variant{157};
4140 static constexpr bool concrete{true};
4141 using subclasses_t = mp::List<>;
4143};
4144template <> struct node_from_variant_t<157> { using type = SgAsmElfNoteEntry; };
4145
4146// Class: AsmElfNoteEntryList
4147template <> struct describe_field_t<SgAsmElfNoteEntryList,SgAsmElfNoteEntryPtrList,&SgAsmElfNoteEntryList::p_entries> {
4149 using field_type = SgAsmElfNoteEntryPtrList;
4150 static constexpr size_t position{0};
4151 static constexpr char const * const name{"entries"};
4152 static constexpr char const * const typestr{"SgAsmElfNoteEntryPtrList"};
4153 static constexpr bool traverse{false};
4154 static constexpr auto mbr_ptr{&SgAsmElfNoteEntryList::p_entries};
4155 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4156 using bind = Desc<SgAsmElfNoteEntryList, SgAsmElfNoteEntryPtrList SgAsmElfNoteEntryList::*, &SgAsmElfNoteEntryList::p_entries>;
4157};
4161 static constexpr char const * const name{"AsmElfNoteEntryList"};
4162 static constexpr unsigned long variant{158};
4163 static constexpr bool concrete{true};
4164 using subclasses_t = mp::List<>;
4166};
4167template <> struct node_from_variant_t<158> { using type = SgAsmElfNoteEntryList; };
4168
4169// Class: AsmElfNoteSection
4170template <> struct describe_field_t<SgAsmElfNoteSection,SgAsmElfNoteEntryList*,&SgAsmElfNoteSection::p_entries> {
4173 static constexpr size_t position{0};
4174 static constexpr char const * const name{"entries"};
4175 static constexpr char const * const typestr{"SgAsmElfNoteEntryList*"};
4176 static constexpr bool traverse{true};
4177 static constexpr auto mbr_ptr{&SgAsmElfNoteSection::p_entries};
4178 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4179 using bind = Desc<SgAsmElfNoteSection, SgAsmElfNoteEntryList* SgAsmElfNoteSection::*, &SgAsmElfNoteSection::p_entries>;
4180};
4182 using node = SgAsmElfNoteSection;
4183 using base = SgAsmElfSection;
4184 static constexpr char const * const name{"AsmElfNoteSection"};
4185 static constexpr unsigned long variant{159};
4186 static constexpr bool concrete{true};
4187 using subclasses_t = mp::List<>;
4189};
4190template <> struct node_from_variant_t<159> { using type = SgAsmElfNoteSection; };
4191
4192// Class: AsmElfRelocEntry
4193template <> struct describe_field_t<SgAsmElfRelocEntry,Rose::BinaryAnalysis::Address,&SgAsmElfRelocEntry::p_r_offset> {
4194 using parent = SgAsmElfRelocEntry;
4195 using field_type = Rose::BinaryAnalysis::Address;
4196 static constexpr size_t position{0};
4197 static constexpr char const * const name{"r_offset"};
4198 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
4199 static constexpr bool traverse{false};
4200 static constexpr auto mbr_ptr{&SgAsmElfRelocEntry::p_r_offset};
4201 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4202 using bind = Desc<SgAsmElfRelocEntry, Rose::BinaryAnalysis::Address SgAsmElfRelocEntry::*, &SgAsmElfRelocEntry::p_r_offset>;
4203};
4204template <> struct describe_field_t<SgAsmElfRelocEntry,Rose::BinaryAnalysis::Address,&SgAsmElfRelocEntry::p_r_addend> {
4205 using parent = SgAsmElfRelocEntry;
4206 using field_type = Rose::BinaryAnalysis::Address;
4207 static constexpr size_t position{1};
4208 static constexpr char const * const name{"r_addend"};
4209 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
4210 static constexpr bool traverse{false};
4211 static constexpr auto mbr_ptr{&SgAsmElfRelocEntry::p_r_addend};
4212 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4213 using bind = Desc<SgAsmElfRelocEntry, Rose::BinaryAnalysis::Address SgAsmElfRelocEntry::*, &SgAsmElfRelocEntry::p_r_addend>;
4214};
4215template <> struct describe_field_t<SgAsmElfRelocEntry,unsigned long,&SgAsmElfRelocEntry::p_sym> {
4216 using parent = SgAsmElfRelocEntry;
4217 using field_type = unsigned long;
4218 static constexpr size_t position{2};
4219 static constexpr char const * const name{"sym"};
4220 static constexpr char const * const typestr{"unsigned long"};
4221 static constexpr bool traverse{false};
4222 static constexpr auto mbr_ptr{&SgAsmElfRelocEntry::p_sym};
4223 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4224 using bind = Desc<SgAsmElfRelocEntry, unsigned long SgAsmElfRelocEntry::*, &SgAsmElfRelocEntry::p_sym>;
4225};
4226template <> struct describe_field_t<SgAsmElfRelocEntry,SgAsmElfRelocEntry::RelocType,&SgAsmElfRelocEntry::p_type> {
4227 using parent = SgAsmElfRelocEntry;
4229 static constexpr size_t position{3};
4230 static constexpr char const * const name{"type"};
4231 static constexpr char const * const typestr{"SgAsmElfRelocEntry::RelocType"};
4232 static constexpr bool traverse{false};
4233 static constexpr auto mbr_ptr{&SgAsmElfRelocEntry::p_type};
4234 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4235 using bind = Desc<SgAsmElfRelocEntry, SgAsmElfRelocEntry::RelocType SgAsmElfRelocEntry::*, &SgAsmElfRelocEntry::p_type>;
4236};
4237template <> struct describe_field_t<SgAsmElfRelocEntry,SgUnsignedCharList,&SgAsmElfRelocEntry::p_extra> {
4238 using parent = SgAsmElfRelocEntry;
4239 using field_type = SgUnsignedCharList;
4240 static constexpr size_t position{4};
4241 static constexpr char const * const name{"extra"};
4242 static constexpr char const * const typestr{"SgUnsignedCharList"};
4243 static constexpr bool traverse{false};
4244 static constexpr auto mbr_ptr{&SgAsmElfRelocEntry::p_extra};
4245 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4246 using bind = Desc<SgAsmElfRelocEntry, SgUnsignedCharList SgAsmElfRelocEntry::*, &SgAsmElfRelocEntry::p_extra>;
4247};
4257template <> struct node_from_variant_t<160> { using type = SgAsmElfRelocEntry; };
4258
4259// Class: AsmElfRelocEntryList
4260template <> struct describe_field_t<SgAsmElfRelocEntryList,SgAsmElfRelocEntryPtrList,&SgAsmElfRelocEntryList::p_entries> {
4262 using field_type = SgAsmElfRelocEntryPtrList;
4263 static constexpr size_t position{0};
4264 static constexpr char const * const name{"entries"};
4265 static constexpr char const * const typestr{"SgAsmElfRelocEntryPtrList"};
4266 static constexpr bool traverse{true};
4267 static constexpr auto mbr_ptr{&SgAsmElfRelocEntryList::p_entries};
4268 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4269 using bind = Desc<SgAsmElfRelocEntryList, SgAsmElfRelocEntryPtrList SgAsmElfRelocEntryList::*, &SgAsmElfRelocEntryList::p_entries>;
4270};
4274 static constexpr char const * const name{"AsmElfRelocEntryList"};
4275 static constexpr unsigned long variant{161};
4276 static constexpr bool concrete{true};
4277 using subclasses_t = mp::List<>;
4279};
4280template <> struct node_from_variant_t<161> { using type = SgAsmElfRelocEntryList; };
4281
4282// Class: AsmElfRelocSection
4283template <> struct describe_field_t<SgAsmElfRelocSection,bool,&SgAsmElfRelocSection::p_usesAddend> {
4285 using field_type = bool;
4286 static constexpr size_t position{0};
4287 static constexpr char const * const name{"usesAddend"};
4288 static constexpr char const * const typestr{"bool"};
4289 static constexpr bool traverse{false};
4290 static constexpr auto mbr_ptr{&SgAsmElfRelocSection::p_usesAddend};
4291 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4292 using bind = Desc<SgAsmElfRelocSection, bool SgAsmElfRelocSection::*, &SgAsmElfRelocSection::p_usesAddend>;
4293};
4294template <> struct describe_field_t<SgAsmElfRelocSection,SgAsmElfSection*,&SgAsmElfRelocSection::p_targetSection> {
4296 using field_type = SgAsmElfSection*;
4297 static constexpr size_t position{1};
4298 static constexpr char const * const name{"targetSection"};
4299 static constexpr char const * const typestr{"SgAsmElfSection*"};
4300 static constexpr bool traverse{false};
4301 static constexpr auto mbr_ptr{&SgAsmElfRelocSection::p_targetSection};
4302 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4303 using bind = Desc<SgAsmElfRelocSection, SgAsmElfSection* SgAsmElfRelocSection::*, &SgAsmElfRelocSection::p_targetSection>;
4304};
4305template <> struct describe_field_t<SgAsmElfRelocSection,SgAsmElfRelocEntryList*,&SgAsmElfRelocSection::p_entries> {
4308 static constexpr size_t position{2};
4309 static constexpr char const * const name{"entries"};
4310 static constexpr char const * const typestr{"SgAsmElfRelocEntryList*"};
4311 static constexpr bool traverse{true};
4312 static constexpr auto mbr_ptr{&SgAsmElfRelocSection::p_entries};
4313 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4314 using bind = Desc<SgAsmElfRelocSection, SgAsmElfRelocEntryList* SgAsmElfRelocSection::*, &SgAsmElfRelocSection::p_entries>;
4315};
4317 using node = SgAsmElfRelocSection;
4318 using base = SgAsmElfSection;
4319 static constexpr char const * const name{"AsmElfRelocSection"};
4320 static constexpr unsigned long variant{162};
4321 static constexpr bool concrete{true};
4322 using subclasses_t = mp::List<>;
4324};
4325template <> struct node_from_variant_t<162> { using type = SgAsmElfRelocSection; };
4326
4327// Class: AsmElfSection
4328template <> struct describe_field_t<SgAsmElfSection,SgAsmElfSection*,&SgAsmElfSection::p_linkedSection> {
4329 using parent = SgAsmElfSection;
4330 using field_type = SgAsmElfSection*;
4331 static constexpr size_t position{0};
4332 static constexpr char const * const name{"linkedSection"};
4333 static constexpr char const * const typestr{"SgAsmElfSection*"};
4334 static constexpr bool traverse{false};
4335 static constexpr auto mbr_ptr{&SgAsmElfSection::p_linkedSection};
4336 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4337 using bind = Desc<SgAsmElfSection, SgAsmElfSection* SgAsmElfSection::*, &SgAsmElfSection::p_linkedSection>;
4338};
4339template <> struct describe_field_t<SgAsmElfSection,SgAsmElfSectionTableEntry*,&SgAsmElfSection::p_sectionEntry> {
4340 using parent = SgAsmElfSection;
4342 static constexpr size_t position{1};
4343 static constexpr char const * const name{"sectionEntry"};
4344 static constexpr char const * const typestr{"SgAsmElfSectionTableEntry*"};
4345 static constexpr bool traverse{true};
4346 static constexpr auto mbr_ptr{&SgAsmElfSection::p_sectionEntry};
4347 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4348 using bind = Desc<SgAsmElfSection, SgAsmElfSectionTableEntry* SgAsmElfSection::*, &SgAsmElfSection::p_sectionEntry>;
4349};
4350template <> struct describe_field_t<SgAsmElfSection,SgAsmElfSegmentTableEntry*,&SgAsmElfSection::p_segmentEntry> {
4351 using parent = SgAsmElfSection;
4353 static constexpr size_t position{2};
4354 static constexpr char const * const name{"segmentEntry"};
4355 static constexpr char const * const typestr{"SgAsmElfSegmentTableEntry*"};
4356 static constexpr bool traverse{true};
4357 static constexpr auto mbr_ptr{&SgAsmElfSection::p_segmentEntry};
4358 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4359 using bind = Desc<SgAsmElfSection, SgAsmElfSegmentTableEntry* SgAsmElfSection::*, &SgAsmElfSection::p_segmentEntry>;
4360};
4370template <> struct node_from_variant_t<163> { using type = SgAsmElfSection; };
4371
4372// Class: AsmElfSectionTable
4374 using node = SgAsmElfSectionTable;
4375 using base = SgAsmGenericSection;
4376 static constexpr char const * const name{"AsmElfSectionTable"};
4377 static constexpr unsigned long variant{164};
4378 static constexpr bool concrete{true};
4379 using subclasses_t = mp::List<>;
4380 using fields_t = mp::List<>;
4381};
4382template <> struct node_from_variant_t<164> { using type = SgAsmElfSectionTable; };
4383
4384// Class: AsmElfSectionTableEntry
4385template <> struct describe_field_t<SgAsmElfSectionTableEntry,unsigned,&SgAsmElfSectionTableEntry::p_sh_name> {
4387 using field_type = unsigned;
4388 static constexpr size_t position{0};
4389 static constexpr char const * const name{"sh_name"};
4390 static constexpr char const * const typestr{"unsigned"};
4391 static constexpr bool traverse{false};
4392 static constexpr auto mbr_ptr{&SgAsmElfSectionTableEntry::p_sh_name};
4393 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4394 using bind = Desc<SgAsmElfSectionTableEntry, unsigned SgAsmElfSectionTableEntry::*, &SgAsmElfSectionTableEntry::p_sh_name>;
4395};
4396template <> struct describe_field_t<SgAsmElfSectionTableEntry,SgAsmElfSectionTableEntry::SectionType,&SgAsmElfSectionTableEntry::p_sh_type> {
4399 static constexpr size_t position{1};
4400 static constexpr char const * const name{"sh_type"};
4401 static constexpr char const * const typestr{"SgAsmElfSectionTableEntry::SectionType"};
4402 static constexpr bool traverse{false};
4403 static constexpr auto mbr_ptr{&SgAsmElfSectionTableEntry::p_sh_type};
4404 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4405 using bind = Desc<SgAsmElfSectionTableEntry, SgAsmElfSectionTableEntry::SectionType SgAsmElfSectionTableEntry::*, &SgAsmElfSectionTableEntry::p_sh_type>;
4406};
4407template <> struct describe_field_t<SgAsmElfSectionTableEntry,unsigned long,&SgAsmElfSectionTableEntry::p_sh_link> {
4409 using field_type = unsigned long;
4410 static constexpr size_t position{2};
4411 static constexpr char const * const name{"sh_link"};
4412 static constexpr char const * const typestr{"unsigned long"};
4413 static constexpr bool traverse{false};
4414 static constexpr auto mbr_ptr{&SgAsmElfSectionTableEntry::p_sh_link};
4415 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4416 using bind = Desc<SgAsmElfSectionTableEntry, unsigned long SgAsmElfSectionTableEntry::*, &SgAsmElfSectionTableEntry::p_sh_link>;
4417};
4418template <> struct describe_field_t<SgAsmElfSectionTableEntry,unsigned long,&SgAsmElfSectionTableEntry::p_sh_info> {
4420 using field_type = unsigned long;
4421 static constexpr size_t position{3};
4422 static constexpr char const * const name{"sh_info"};
4423 static constexpr char const * const typestr{"unsigned long"};
4424 static constexpr bool traverse{false};
4425 static constexpr auto mbr_ptr{&SgAsmElfSectionTableEntry::p_sh_info};
4426 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4427 using bind = Desc<SgAsmElfSectionTableEntry, unsigned long SgAsmElfSectionTableEntry::*, &SgAsmElfSectionTableEntry::p_sh_info>;
4428};
4429template <> struct describe_field_t<SgAsmElfSectionTableEntry,uint64_t,&SgAsmElfSectionTableEntry::p_sh_flags> {
4431 using field_type = uint64_t;
4432 static constexpr size_t position{4};
4433 static constexpr char const * const name{"sh_flags"};
4434 static constexpr char const * const typestr{"uint64_t"};
4435 static constexpr bool traverse{false};
4436 static constexpr auto mbr_ptr{&SgAsmElfSectionTableEntry::p_sh_flags};
4437 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4438 using bind = Desc<SgAsmElfSectionTableEntry, uint64_t SgAsmElfSectionTableEntry::*, &SgAsmElfSectionTableEntry::p_sh_flags>;
4439};
4440template <> struct describe_field_t<SgAsmElfSectionTableEntry,Rose::BinaryAnalysis::Address,&SgAsmElfSectionTableEntry::p_sh_addr> {
4442 using field_type = Rose::BinaryAnalysis::Address;
4443 static constexpr size_t position{5};
4444 static constexpr char const * const name{"sh_addr"};
4445 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
4446 static constexpr bool traverse{false};
4447 static constexpr auto mbr_ptr{&SgAsmElfSectionTableEntry::p_sh_addr};
4448 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4449 using bind = Desc<SgAsmElfSectionTableEntry, Rose::BinaryAnalysis::Address SgAsmElfSectionTableEntry::*, &SgAsmElfSectionTableEntry::p_sh_addr>;
4450};
4451template <> struct describe_field_t<SgAsmElfSectionTableEntry,Rose::BinaryAnalysis::Address,&SgAsmElfSectionTableEntry::p_sh_offset> {
4453 using field_type = Rose::BinaryAnalysis::Address;
4454 static constexpr size_t position{6};
4455 static constexpr char const * const name{"sh_offset"};
4456 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
4457 static constexpr bool traverse{false};
4458 static constexpr auto mbr_ptr{&SgAsmElfSectionTableEntry::p_sh_offset};
4459 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4460 using bind = Desc<SgAsmElfSectionTableEntry, Rose::BinaryAnalysis::Address SgAsmElfSectionTableEntry::*, &SgAsmElfSectionTableEntry::p_sh_offset>;
4461};
4462template <> struct describe_field_t<SgAsmElfSectionTableEntry,Rose::BinaryAnalysis::Address,&SgAsmElfSectionTableEntry::p_sh_size> {
4464 using field_type = Rose::BinaryAnalysis::Address;
4465 static constexpr size_t position{7};
4466 static constexpr char const * const name{"sh_size"};
4467 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
4468 static constexpr bool traverse{false};
4469 static constexpr auto mbr_ptr{&SgAsmElfSectionTableEntry::p_sh_size};
4470 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4471 using bind = Desc<SgAsmElfSectionTableEntry, Rose::BinaryAnalysis::Address SgAsmElfSectionTableEntry::*, &SgAsmElfSectionTableEntry::p_sh_size>;
4472};
4473template <> struct describe_field_t<SgAsmElfSectionTableEntry,Rose::BinaryAnalysis::Address,&SgAsmElfSectionTableEntry::p_sh_addralign> {
4475 using field_type = Rose::BinaryAnalysis::Address;
4476 static constexpr size_t position{8};
4477 static constexpr char const * const name{"sh_addralign"};
4478 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
4479 static constexpr bool traverse{false};
4480 static constexpr auto mbr_ptr{&SgAsmElfSectionTableEntry::p_sh_addralign};
4481 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4482 using bind = Desc<SgAsmElfSectionTableEntry, Rose::BinaryAnalysis::Address SgAsmElfSectionTableEntry::*, &SgAsmElfSectionTableEntry::p_sh_addralign>;
4483};
4484template <> struct describe_field_t<SgAsmElfSectionTableEntry,Rose::BinaryAnalysis::Address,&SgAsmElfSectionTableEntry::p_sh_entsize> {
4486 using field_type = Rose::BinaryAnalysis::Address;
4487 static constexpr size_t position{9};
4488 static constexpr char const * const name{"sh_entsize"};
4489 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
4490 static constexpr bool traverse{false};
4491 static constexpr auto mbr_ptr{&SgAsmElfSectionTableEntry::p_sh_entsize};
4492 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4493 using bind = Desc<SgAsmElfSectionTableEntry, Rose::BinaryAnalysis::Address SgAsmElfSectionTableEntry::*, &SgAsmElfSectionTableEntry::p_sh_entsize>;
4494};
4495template <> struct describe_field_t<SgAsmElfSectionTableEntry,SgUnsignedCharList,&SgAsmElfSectionTableEntry::p_extra> {
4497 using field_type = SgUnsignedCharList;
4498 static constexpr size_t position{10};
4499 static constexpr char const * const name{"extra"};
4500 static constexpr char const * const typestr{"SgUnsignedCharList"};
4501 static constexpr bool traverse{false};
4502 static constexpr auto mbr_ptr{&SgAsmElfSectionTableEntry::p_extra};
4503 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4504 using bind = Desc<SgAsmElfSectionTableEntry, SgUnsignedCharList SgAsmElfSectionTableEntry::*, &SgAsmElfSectionTableEntry::p_extra>;
4505};
4509 static constexpr char const * const name{"AsmElfSectionTableEntry"};
4510 static constexpr unsigned long variant{165};
4511 static constexpr bool concrete{true};
4512 using subclasses_t = mp::List<>;
4514};
4515template <> struct node_from_variant_t<165> { using type = SgAsmElfSectionTableEntry; };
4516
4517// Class: AsmElfSegmentTable
4519 using node = SgAsmElfSegmentTable;
4520 using base = SgAsmGenericSection;
4521 static constexpr char const * const name{"AsmElfSegmentTable"};
4522 static constexpr unsigned long variant{166};
4523 static constexpr bool concrete{true};
4524 using subclasses_t = mp::List<>;
4525 using fields_t = mp::List<>;
4526};
4527template <> struct node_from_variant_t<166> { using type = SgAsmElfSegmentTable; };
4528
4529// Class: AsmElfSegmentTableEntry
4530template <> struct describe_field_t<SgAsmElfSegmentTableEntry,size_t,&SgAsmElfSegmentTableEntry::p_index> {
4532 using field_type = size_t;
4533 static constexpr size_t position{0};
4534 static constexpr char const * const name{"index"};
4535 static constexpr char const * const typestr{"size_t"};
4536 static constexpr bool traverse{false};
4537 static constexpr auto mbr_ptr{&SgAsmElfSegmentTableEntry::p_index};
4538 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4539 using bind = Desc<SgAsmElfSegmentTableEntry, size_t SgAsmElfSegmentTableEntry::*, &SgAsmElfSegmentTableEntry::p_index>;
4540};
4541template <> struct describe_field_t<SgAsmElfSegmentTableEntry,SgAsmElfSegmentTableEntry::SegmentType,&SgAsmElfSegmentTableEntry::p_type> {
4544 static constexpr size_t position{1};
4545 static constexpr char const * const name{"type"};
4546 static constexpr char const * const typestr{"SgAsmElfSegmentTableEntry::SegmentType"};
4547 static constexpr bool traverse{false};
4548 static constexpr auto mbr_ptr{&SgAsmElfSegmentTableEntry::p_type};
4549 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4550 using bind = Desc<SgAsmElfSegmentTableEntry, SgAsmElfSegmentTableEntry::SegmentType SgAsmElfSegmentTableEntry::*, &SgAsmElfSegmentTableEntry::p_type>;
4551};
4552template <> struct describe_field_t<SgAsmElfSegmentTableEntry,SgAsmElfSegmentTableEntry::SegmentFlags,&SgAsmElfSegmentTableEntry::p_flags> {
4555 static constexpr size_t position{2};
4556 static constexpr char const * const name{"flags"};
4557 static constexpr char const * const typestr{"SgAsmElfSegmentTableEntry::SegmentFlags"};
4558 static constexpr bool traverse{false};
4559 static constexpr auto mbr_ptr{&SgAsmElfSegmentTableEntry::p_flags};
4560 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4561 using bind = Desc<SgAsmElfSegmentTableEntry, SgAsmElfSegmentTableEntry::SegmentFlags SgAsmElfSegmentTableEntry::*, &SgAsmElfSegmentTableEntry::p_flags>;
4562};
4563template <> struct describe_field_t<SgAsmElfSegmentTableEntry,Rose::BinaryAnalysis::Address,&SgAsmElfSegmentTableEntry::p_offset> {
4565 using field_type = Rose::BinaryAnalysis::Address;
4566 static constexpr size_t position{3};
4567 static constexpr char const * const name{"offset"};
4568 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
4569 static constexpr bool traverse{false};
4570 static constexpr auto mbr_ptr{&SgAsmElfSegmentTableEntry::p_offset};
4571 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4572 using bind = Desc<SgAsmElfSegmentTableEntry, Rose::BinaryAnalysis::Address SgAsmElfSegmentTableEntry::*, &SgAsmElfSegmentTableEntry::p_offset>;
4573};
4574template <> struct describe_field_t<SgAsmElfSegmentTableEntry,Rose::BinaryAnalysis::Address,&SgAsmElfSegmentTableEntry::p_vaddr> {
4576 using field_type = Rose::BinaryAnalysis::Address;
4577 static constexpr size_t position{4};
4578 static constexpr char const * const name{"vaddr"};
4579 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
4580 static constexpr bool traverse{false};
4581 static constexpr auto mbr_ptr{&SgAsmElfSegmentTableEntry::p_vaddr};
4582 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4583 using bind = Desc<SgAsmElfSegmentTableEntry, Rose::BinaryAnalysis::Address SgAsmElfSegmentTableEntry::*, &SgAsmElfSegmentTableEntry::p_vaddr>;
4584};
4585template <> struct describe_field_t<SgAsmElfSegmentTableEntry,Rose::BinaryAnalysis::Address,&SgAsmElfSegmentTableEntry::p_paddr> {
4587 using field_type = Rose::BinaryAnalysis::Address;
4588 static constexpr size_t position{5};
4589 static constexpr char const * const name{"paddr"};
4590 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
4591 static constexpr bool traverse{false};
4592 static constexpr auto mbr_ptr{&SgAsmElfSegmentTableEntry::p_paddr};
4593 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4594 using bind = Desc<SgAsmElfSegmentTableEntry, Rose::BinaryAnalysis::Address SgAsmElfSegmentTableEntry::*, &SgAsmElfSegmentTableEntry::p_paddr>;
4595};
4596template <> struct describe_field_t<SgAsmElfSegmentTableEntry,Rose::BinaryAnalysis::Address,&SgAsmElfSegmentTableEntry::p_filesz> {
4598 using field_type = Rose::BinaryAnalysis::Address;
4599 static constexpr size_t position{6};
4600 static constexpr char const * const name{"filesz"};
4601 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
4602 static constexpr bool traverse{false};
4603 static constexpr auto mbr_ptr{&SgAsmElfSegmentTableEntry::p_filesz};
4604 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4605 using bind = Desc<SgAsmElfSegmentTableEntry, Rose::BinaryAnalysis::Address SgAsmElfSegmentTableEntry::*, &SgAsmElfSegmentTableEntry::p_filesz>;
4606};
4607template <> struct describe_field_t<SgAsmElfSegmentTableEntry,Rose::BinaryAnalysis::Address,&SgAsmElfSegmentTableEntry::p_memsz> {
4609 using field_type = Rose::BinaryAnalysis::Address;
4610 static constexpr size_t position{7};
4611 static constexpr char const * const name{"memsz"};
4612 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
4613 static constexpr bool traverse{false};
4614 static constexpr auto mbr_ptr{&SgAsmElfSegmentTableEntry::p_memsz};
4615 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4616 using bind = Desc<SgAsmElfSegmentTableEntry, Rose::BinaryAnalysis::Address SgAsmElfSegmentTableEntry::*, &SgAsmElfSegmentTableEntry::p_memsz>;
4617};
4618template <> struct describe_field_t<SgAsmElfSegmentTableEntry,Rose::BinaryAnalysis::Address,&SgAsmElfSegmentTableEntry::p_align> {
4620 using field_type = Rose::BinaryAnalysis::Address;
4621 static constexpr size_t position{8};
4622 static constexpr char const * const name{"align"};
4623 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
4624 static constexpr bool traverse{false};
4625 static constexpr auto mbr_ptr{&SgAsmElfSegmentTableEntry::p_align};
4626 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4627 using bind = Desc<SgAsmElfSegmentTableEntry, Rose::BinaryAnalysis::Address SgAsmElfSegmentTableEntry::*, &SgAsmElfSegmentTableEntry::p_align>;
4628};
4629template <> struct describe_field_t<SgAsmElfSegmentTableEntry,SgUnsignedCharList,&SgAsmElfSegmentTableEntry::p_extra> {
4631 using field_type = SgUnsignedCharList;
4632 static constexpr size_t position{9};
4633 static constexpr char const * const name{"extra"};
4634 static constexpr char const * const typestr{"SgUnsignedCharList"};
4635 static constexpr bool traverse{false};
4636 static constexpr auto mbr_ptr{&SgAsmElfSegmentTableEntry::p_extra};
4637 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4638 using bind = Desc<SgAsmElfSegmentTableEntry, SgUnsignedCharList SgAsmElfSegmentTableEntry::*, &SgAsmElfSegmentTableEntry::p_extra>;
4639};
4649template <> struct node_from_variant_t<167> { using type = SgAsmElfSegmentTableEntry; };
4650
4651// Class: AsmElfSegmentTableEntryList
4652template <> struct describe_field_t<SgAsmElfSegmentTableEntryList,SgAsmElfSegmentTableEntryPtrList,&SgAsmElfSegmentTableEntryList::p_entries> {
4654 using field_type = SgAsmElfSegmentTableEntryPtrList;
4655 static constexpr size_t position{0};
4656 static constexpr char const * const name{"entries"};
4657 static constexpr char const * const typestr{"SgAsmElfSegmentTableEntryPtrList"};
4658 static constexpr bool traverse{true};
4659 static constexpr auto mbr_ptr{&SgAsmElfSegmentTableEntryList::p_entries};
4660 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4661 using bind = Desc<SgAsmElfSegmentTableEntryList, SgAsmElfSegmentTableEntryPtrList SgAsmElfSegmentTableEntryList::*, &SgAsmElfSegmentTableEntryList::p_entries>;
4662};
4666 static constexpr char const * const name{"AsmElfSegmentTableEntryList"};
4667 static constexpr unsigned long variant{168};
4668 static constexpr bool concrete{true};
4669 using subclasses_t = mp::List<>;
4671};
4672template <> struct node_from_variant_t<168> { using type = SgAsmElfSegmentTableEntryList; };
4673
4674// Class: AsmElfStringSection
4675template <> struct describe_field_t<SgAsmElfStringSection,SgAsmElfStrtab*,&SgAsmElfStringSection::p_strtab> {
4677 using field_type = SgAsmElfStrtab*;
4678 static constexpr size_t position{0};
4679 static constexpr char const * const name{"strtab"};
4680 static constexpr char const * const typestr{"SgAsmElfStrtab*"};
4681 static constexpr bool traverse{false};
4682 static constexpr auto mbr_ptr{&SgAsmElfStringSection::p_strtab};
4683 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4684 using bind = Desc<SgAsmElfStringSection, SgAsmElfStrtab* SgAsmElfStringSection::*, &SgAsmElfStringSection::p_strtab>;
4685};
4688 using base = SgAsmElfSection;
4689 static constexpr char const * const name{"AsmElfStringSection"};
4690 static constexpr unsigned long variant{169};
4691 static constexpr bool concrete{true};
4692 using subclasses_t = mp::List<>;
4694};
4695template <> struct node_from_variant_t<169> { using type = SgAsmElfStringSection; };
4696
4697// Class: AsmElfStrtab
4698template <> struct describe_node_t<SgAsmElfStrtab> {
4699 using node = SgAsmElfStrtab;
4700 using base = SgAsmGenericStrtab;
4701 static constexpr char const * const name{"AsmElfStrtab"};
4702 static constexpr unsigned long variant{170};
4703 static constexpr bool concrete{true};
4704 using subclasses_t = mp::List<>;
4705 using fields_t = mp::List<>;
4706};
4707template <> struct node_from_variant_t<170> { using type = SgAsmElfStrtab; };
4708
4709// Class: AsmElfSymbol
4710template <> struct describe_field_t<SgAsmElfSymbol,unsigned char,&SgAsmElfSymbol::p_st_info> {
4711 using parent = SgAsmElfSymbol;
4712 using field_type = unsigned char;
4713 static constexpr size_t position{0};
4714 static constexpr char const * const name{"st_info"};
4715 static constexpr char const * const typestr{"unsigned char"};
4716 static constexpr bool traverse{false};
4717 static constexpr auto mbr_ptr{&SgAsmElfSymbol::p_st_info};
4718 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4719 using bind = Desc<SgAsmElfSymbol, unsigned char SgAsmElfSymbol::*, &SgAsmElfSymbol::p_st_info>;
4720};
4721template <> struct describe_field_t<SgAsmElfSymbol,unsigned char,&SgAsmElfSymbol::p_st_res1> {
4722 using parent = SgAsmElfSymbol;
4723 using field_type = unsigned char;
4724 static constexpr size_t position{1};
4725 static constexpr char const * const name{"st_res1"};
4726 static constexpr char const * const typestr{"unsigned char"};
4727 static constexpr bool traverse{false};
4728 static constexpr auto mbr_ptr{&SgAsmElfSymbol::p_st_res1};
4729 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4730 using bind = Desc<SgAsmElfSymbol, unsigned char SgAsmElfSymbol::*, &SgAsmElfSymbol::p_st_res1>;
4731};
4732template <> struct describe_field_t<SgAsmElfSymbol,unsigned,&SgAsmElfSymbol::p_st_shndx> {
4733 using parent = SgAsmElfSymbol;
4734 using field_type = unsigned;
4735 static constexpr size_t position{2};
4736 static constexpr char const * const name{"st_shndx"};
4737 static constexpr char const * const typestr{"unsigned"};
4738 static constexpr bool traverse{false};
4739 static constexpr auto mbr_ptr{&SgAsmElfSymbol::p_st_shndx};
4740 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4741 using bind = Desc<SgAsmElfSymbol, unsigned SgAsmElfSymbol::*, &SgAsmElfSymbol::p_st_shndx>;
4742};
4743template <> struct describe_field_t<SgAsmElfSymbol,Rose::BinaryAnalysis::Address,&SgAsmElfSymbol::p_st_size> {
4744 using parent = SgAsmElfSymbol;
4745 using field_type = Rose::BinaryAnalysis::Address;
4746 static constexpr size_t position{3};
4747 static constexpr char const * const name{"st_size"};
4748 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
4749 static constexpr bool traverse{false};
4750 static constexpr auto mbr_ptr{&SgAsmElfSymbol::p_st_size};
4751 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4752 using bind = Desc<SgAsmElfSymbol, Rose::BinaryAnalysis::Address SgAsmElfSymbol::*, &SgAsmElfSymbol::p_st_size>;
4753};
4754template <> struct describe_field_t<SgAsmElfSymbol,SgUnsignedCharList,&SgAsmElfSymbol::p_extra> {
4755 using parent = SgAsmElfSymbol;
4756 using field_type = SgUnsignedCharList;
4757 static constexpr size_t position{4};
4758 static constexpr char const * const name{"extra"};
4759 static constexpr char const * const typestr{"SgUnsignedCharList"};
4760 static constexpr bool traverse{false};
4761 static constexpr auto mbr_ptr{&SgAsmElfSymbol::p_extra};
4762 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4763 using bind = Desc<SgAsmElfSymbol, SgUnsignedCharList SgAsmElfSymbol::*, &SgAsmElfSymbol::p_extra>;
4764};
4774template <> struct node_from_variant_t<171> { using type = SgAsmElfSymbol; };
4775
4776// Class: AsmElfSymbolList
4777template <> struct describe_field_t<SgAsmElfSymbolList,SgAsmElfSymbolPtrList,&SgAsmElfSymbolList::p_symbols> {
4778 using parent = SgAsmElfSymbolList;
4779 using field_type = SgAsmElfSymbolPtrList;
4780 static constexpr size_t position{0};
4781 static constexpr char const * const name{"symbols"};
4782 static constexpr char const * const typestr{"SgAsmElfSymbolPtrList"};
4783 static constexpr bool traverse{true};
4784 static constexpr auto mbr_ptr{&SgAsmElfSymbolList::p_symbols};
4785 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4786 using bind = Desc<SgAsmElfSymbolList, SgAsmElfSymbolPtrList SgAsmElfSymbolList::*, &SgAsmElfSymbolList::p_symbols>;
4787};
4789 using node = SgAsmElfSymbolList;
4791 static constexpr char const * const name{"AsmElfSymbolList"};
4792 static constexpr unsigned long variant{172};
4793 static constexpr bool concrete{true};
4794 using subclasses_t = mp::List<>;
4796};
4797template <> struct node_from_variant_t<172> { using type = SgAsmElfSymbolList; };
4798
4799// Class: AsmElfSymbolSection
4800template <> struct describe_field_t<SgAsmElfSymbolSection,bool,&SgAsmElfSymbolSection::p_isDynamic> {
4802 using field_type = bool;
4803 static constexpr size_t position{0};
4804 static constexpr char const * const name{"isDynamic"};
4805 static constexpr char const * const typestr{"bool"};
4806 static constexpr bool traverse{false};
4807 static constexpr auto mbr_ptr{&SgAsmElfSymbolSection::p_isDynamic};
4808 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4809 using bind = Desc<SgAsmElfSymbolSection, bool SgAsmElfSymbolSection::*, &SgAsmElfSymbolSection::p_isDynamic>;
4810};
4811template <> struct describe_field_t<SgAsmElfSymbolSection,SgAsmElfSymbolList*,&SgAsmElfSymbolSection::p_symbols> {
4814 static constexpr size_t position{1};
4815 static constexpr char const * const name{"symbols"};
4816 static constexpr char const * const typestr{"SgAsmElfSymbolList*"};
4817 static constexpr bool traverse{true};
4818 static constexpr auto mbr_ptr{&SgAsmElfSymbolSection::p_symbols};
4819 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4820 using bind = Desc<SgAsmElfSymbolSection, SgAsmElfSymbolList* SgAsmElfSymbolSection::*, &SgAsmElfSymbolSection::p_symbols>;
4821};
4824 using base = SgAsmElfSection;
4825 static constexpr char const * const name{"AsmElfSymbolSection"};
4826 static constexpr unsigned long variant{173};
4827 static constexpr bool concrete{true};
4828 using subclasses_t = mp::List<>;
4830};
4831template <> struct node_from_variant_t<173> { using type = SgAsmElfSymbolSection; };
4832
4833// Class: AsmElfSymverDefinedAux
4834template <> struct describe_field_t<SgAsmElfSymverDefinedAux,SgAsmGenericString*,&SgAsmElfSymverDefinedAux::p_name> {
4837 static constexpr size_t position{0};
4838 static constexpr char const * const name{"name"};
4839 static constexpr char const * const typestr{"SgAsmGenericString*"};
4840 static constexpr bool traverse{true};
4841 static constexpr auto mbr_ptr{&SgAsmElfSymverDefinedAux::p_name};
4842 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4843 using bind = Desc<SgAsmElfSymverDefinedAux, SgAsmGenericString* SgAsmElfSymverDefinedAux::*, &SgAsmElfSymverDefinedAux::p_name>;
4844};
4848 static constexpr char const * const name{"AsmElfSymverDefinedAux"};
4849 static constexpr unsigned long variant{174};
4850 static constexpr bool concrete{true};
4851 using subclasses_t = mp::List<>;
4853};
4854template <> struct node_from_variant_t<174> { using type = SgAsmElfSymverDefinedAux; };
4855
4856// Class: AsmElfSymverDefinedAuxList
4857template <> struct describe_field_t<SgAsmElfSymverDefinedAuxList,SgAsmElfSymverDefinedAuxPtrList,&SgAsmElfSymverDefinedAuxList::p_entries> {
4859 using field_type = SgAsmElfSymverDefinedAuxPtrList;
4860 static constexpr size_t position{0};
4861 static constexpr char const * const name{"entries"};
4862 static constexpr char const * const typestr{"SgAsmElfSymverDefinedAuxPtrList"};
4863 static constexpr bool traverse{true};
4864 static constexpr auto mbr_ptr{&SgAsmElfSymverDefinedAuxList::p_entries};
4865 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4866 using bind = Desc<SgAsmElfSymverDefinedAuxList, SgAsmElfSymverDefinedAuxPtrList SgAsmElfSymverDefinedAuxList::*, &SgAsmElfSymverDefinedAuxList::p_entries>;
4867};
4871 static constexpr char const * const name{"AsmElfSymverDefinedAuxList"};
4872 static constexpr unsigned long variant{175};
4873 static constexpr bool concrete{true};
4874 using subclasses_t = mp::List<>;
4876};
4877template <> struct node_from_variant_t<175> { using type = SgAsmElfSymverDefinedAuxList; };
4878
4879// Class: AsmElfSymverDefinedEntry
4880template <> struct describe_field_t<SgAsmElfSymverDefinedEntry,size_t,&SgAsmElfSymverDefinedEntry::p_version> {
4882 using field_type = size_t;
4883 static constexpr size_t position{0};
4884 static constexpr char const * const name{"version"};
4885 static constexpr char const * const typestr{"size_t"};
4886 static constexpr bool traverse{false};
4887 static constexpr auto mbr_ptr{&SgAsmElfSymverDefinedEntry::p_version};
4888 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4889 using bind = Desc<SgAsmElfSymverDefinedEntry, size_t SgAsmElfSymverDefinedEntry::*, &SgAsmElfSymverDefinedEntry::p_version>;
4890};
4891template <> struct describe_field_t<SgAsmElfSymverDefinedEntry,int,&SgAsmElfSymverDefinedEntry::p_flags> {
4893 using field_type = int;
4894 static constexpr size_t position{1};
4895 static constexpr char const * const name{"flags"};
4896 static constexpr char const * const typestr{"int"};
4897 static constexpr bool traverse{false};
4898 static constexpr auto mbr_ptr{&SgAsmElfSymverDefinedEntry::p_flags};
4899 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4900 using bind = Desc<SgAsmElfSymverDefinedEntry, int SgAsmElfSymverDefinedEntry::*, &SgAsmElfSymverDefinedEntry::p_flags>;
4901};
4902template <> struct describe_field_t<SgAsmElfSymverDefinedEntry,size_t,&SgAsmElfSymverDefinedEntry::p_index> {
4904 using field_type = size_t;
4905 static constexpr size_t position{2};
4906 static constexpr char const * const name{"index"};
4907 static constexpr char const * const typestr{"size_t"};
4908 static constexpr bool traverse{false};
4909 static constexpr auto mbr_ptr{&SgAsmElfSymverDefinedEntry::p_index};
4910 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4911 using bind = Desc<SgAsmElfSymverDefinedEntry, size_t SgAsmElfSymverDefinedEntry::*, &SgAsmElfSymverDefinedEntry::p_index>;
4912};
4913template <> struct describe_field_t<SgAsmElfSymverDefinedEntry,uint32_t,&SgAsmElfSymverDefinedEntry::p_hash> {
4915 using field_type = uint32_t;
4916 static constexpr size_t position{3};
4917 static constexpr char const * const name{"hash"};
4918 static constexpr char const * const typestr{"uint32_t"};
4919 static constexpr bool traverse{false};
4920 static constexpr auto mbr_ptr{&SgAsmElfSymverDefinedEntry::p_hash};
4921 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4922 using bind = Desc<SgAsmElfSymverDefinedEntry, uint32_t SgAsmElfSymverDefinedEntry::*, &SgAsmElfSymverDefinedEntry::p_hash>;
4923};
4924template <> struct describe_field_t<SgAsmElfSymverDefinedEntry,SgAsmElfSymverDefinedAuxList*,&SgAsmElfSymverDefinedEntry::p_entries> {
4927 static constexpr size_t position{4};
4928 static constexpr char const * const name{"entries"};
4929 static constexpr char const * const typestr{"SgAsmElfSymverDefinedAuxList*"};
4930 static constexpr bool traverse{true};
4931 static constexpr auto mbr_ptr{&SgAsmElfSymverDefinedEntry::p_entries};
4932 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4933 using bind = Desc<SgAsmElfSymverDefinedEntry, SgAsmElfSymverDefinedAuxList* SgAsmElfSymverDefinedEntry::*, &SgAsmElfSymverDefinedEntry::p_entries>;
4934};
4944template <> struct node_from_variant_t<176> { using type = SgAsmElfSymverDefinedEntry; };
4945
4946// Class: AsmElfSymverDefinedEntryList
4947template <> struct describe_field_t<SgAsmElfSymverDefinedEntryList,SgAsmElfSymverDefinedEntryPtrList,&SgAsmElfSymverDefinedEntryList::p_entries> {
4949 using field_type = SgAsmElfSymverDefinedEntryPtrList;
4950 static constexpr size_t position{0};
4951 static constexpr char const * const name{"entries"};
4952 static constexpr char const * const typestr{"SgAsmElfSymverDefinedEntryPtrList"};
4953 static constexpr bool traverse{true};
4954 static constexpr auto mbr_ptr{&SgAsmElfSymverDefinedEntryList::p_entries};
4955 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4956 using bind = Desc<SgAsmElfSymverDefinedEntryList, SgAsmElfSymverDefinedEntryPtrList SgAsmElfSymverDefinedEntryList::*, &SgAsmElfSymverDefinedEntryList::p_entries>;
4957};
4961 static constexpr char const * const name{"AsmElfSymverDefinedEntryList"};
4962 static constexpr unsigned long variant{177};
4963 static constexpr bool concrete{true};
4964 using subclasses_t = mp::List<>;
4966};
4967template <> struct node_from_variant_t<177> { using type = SgAsmElfSymverDefinedEntryList; };
4968
4969// Class: AsmElfSymverDefinedSection
4970template <> struct describe_field_t<SgAsmElfSymverDefinedSection,SgAsmElfSymverDefinedEntryList*,&SgAsmElfSymverDefinedSection::p_entries> {
4973 static constexpr size_t position{0};
4974 static constexpr char const * const name{"entries"};
4975 static constexpr char const * const typestr{"SgAsmElfSymverDefinedEntryList*"};
4976 static constexpr bool traverse{true};
4977 static constexpr auto mbr_ptr{&SgAsmElfSymverDefinedSection::p_entries};
4978 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
4979 using bind = Desc<SgAsmElfSymverDefinedSection, SgAsmElfSymverDefinedEntryList* SgAsmElfSymverDefinedSection::*, &SgAsmElfSymverDefinedSection::p_entries>;
4980};
4983 using base = SgAsmElfSection;
4984 static constexpr char const * const name{"AsmElfSymverDefinedSection"};
4985 static constexpr unsigned long variant{178};
4986 static constexpr bool concrete{true};
4987 using subclasses_t = mp::List<>;
4989};
4990template <> struct node_from_variant_t<178> { using type = SgAsmElfSymverDefinedSection; };
4991
4992// Class: AsmElfSymverEntry
4993template <> struct describe_field_t<SgAsmElfSymverEntry,size_t,&SgAsmElfSymverEntry::p_value> {
4995 using field_type = size_t;
4996 static constexpr size_t position{0};
4997 static constexpr char const * const name{"value"};
4998 static constexpr char const * const typestr{"size_t"};
4999 static constexpr bool traverse{false};
5000 static constexpr auto mbr_ptr{&SgAsmElfSymverEntry::p_value};
5001 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5002 using bind = Desc<SgAsmElfSymverEntry, size_t SgAsmElfSymverEntry::*, &SgAsmElfSymverEntry::p_value>;
5003};
5005 using node = SgAsmElfSymverEntry;
5007 static constexpr char const * const name{"AsmElfSymverEntry"};
5008 static constexpr unsigned long variant{179};
5009 static constexpr bool concrete{true};
5010 using subclasses_t = mp::List<>;
5012};
5013template <> struct node_from_variant_t<179> { using type = SgAsmElfSymverEntry; };
5014
5015// Class: AsmElfSymverEntryList
5016template <> struct describe_field_t<SgAsmElfSymverEntryList,SgAsmElfSymverEntryPtrList,&SgAsmElfSymverEntryList::p_entries> {
5018 using field_type = SgAsmElfSymverEntryPtrList;
5019 static constexpr size_t position{0};
5020 static constexpr char const * const name{"entries"};
5021 static constexpr char const * const typestr{"SgAsmElfSymverEntryPtrList"};
5022 static constexpr bool traverse{true};
5023 static constexpr auto mbr_ptr{&SgAsmElfSymverEntryList::p_entries};
5024 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5025 using bind = Desc<SgAsmElfSymverEntryList, SgAsmElfSymverEntryPtrList SgAsmElfSymverEntryList::*, &SgAsmElfSymverEntryList::p_entries>;
5026};
5030 static constexpr char const * const name{"AsmElfSymverEntryList"};
5031 static constexpr unsigned long variant{180};
5032 static constexpr bool concrete{true};
5033 using subclasses_t = mp::List<>;
5035};
5036template <> struct node_from_variant_t<180> { using type = SgAsmElfSymverEntryList; };
5037
5038// Class: AsmElfSymverNeededAux
5039template <> struct describe_field_t<SgAsmElfSymverNeededAux,uint32_t,&SgAsmElfSymverNeededAux::p_hash> {
5041 using field_type = uint32_t;
5042 static constexpr size_t position{0};
5043 static constexpr char const * const name{"hash"};
5044 static constexpr char const * const typestr{"uint32_t"};
5045 static constexpr bool traverse{false};
5046 static constexpr auto mbr_ptr{&SgAsmElfSymverNeededAux::p_hash};
5047 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5048 using bind = Desc<SgAsmElfSymverNeededAux, uint32_t SgAsmElfSymverNeededAux::*, &SgAsmElfSymverNeededAux::p_hash>;
5049};
5050template <> struct describe_field_t<SgAsmElfSymverNeededAux,int,&SgAsmElfSymverNeededAux::p_flags> {
5052 using field_type = int;
5053 static constexpr size_t position{1};
5054 static constexpr char const * const name{"flags"};
5055 static constexpr char const * const typestr{"int"};
5056 static constexpr bool traverse{false};
5057 static constexpr auto mbr_ptr{&SgAsmElfSymverNeededAux::p_flags};
5058 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5059 using bind = Desc<SgAsmElfSymverNeededAux, int SgAsmElfSymverNeededAux::*, &SgAsmElfSymverNeededAux::p_flags>;
5060};
5061template <> struct describe_field_t<SgAsmElfSymverNeededAux,size_t,&SgAsmElfSymverNeededAux::p_other> {
5063 using field_type = size_t;
5064 static constexpr size_t position{2};
5065 static constexpr char const * const name{"other"};
5066 static constexpr char const * const typestr{"size_t"};
5067 static constexpr bool traverse{false};
5068 static constexpr auto mbr_ptr{&SgAsmElfSymverNeededAux::p_other};
5069 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5070 using bind = Desc<SgAsmElfSymverNeededAux, size_t SgAsmElfSymverNeededAux::*, &SgAsmElfSymverNeededAux::p_other>;
5071};
5072template <> struct describe_field_t<SgAsmElfSymverNeededAux,SgAsmGenericString*,&SgAsmElfSymverNeededAux::p_name> {
5075 static constexpr size_t position{3};
5076 static constexpr char const * const name{"name"};
5077 static constexpr char const * const typestr{"SgAsmGenericString*"};
5078 static constexpr bool traverse{true};
5079 static constexpr auto mbr_ptr{&SgAsmElfSymverNeededAux::p_name};
5080 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5081 using bind = Desc<SgAsmElfSymverNeededAux, SgAsmGenericString* SgAsmElfSymverNeededAux::*, &SgAsmElfSymverNeededAux::p_name>;
5082};
5092template <> struct node_from_variant_t<181> { using type = SgAsmElfSymverNeededAux; };
5093
5094// Class: AsmElfSymverNeededAuxList
5095template <> struct describe_field_t<SgAsmElfSymverNeededAuxList,SgAsmElfSymverNeededAuxPtrList,&SgAsmElfSymverNeededAuxList::p_entries> {
5097 using field_type = SgAsmElfSymverNeededAuxPtrList;
5098 static constexpr size_t position{0};
5099 static constexpr char const * const name{"entries"};
5100 static constexpr char const * const typestr{"SgAsmElfSymverNeededAuxPtrList"};
5101 static constexpr bool traverse{true};
5102 static constexpr auto mbr_ptr{&SgAsmElfSymverNeededAuxList::p_entries};
5103 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5104 using bind = Desc<SgAsmElfSymverNeededAuxList, SgAsmElfSymverNeededAuxPtrList SgAsmElfSymverNeededAuxList::*, &SgAsmElfSymverNeededAuxList::p_entries>;
5105};
5109 static constexpr char const * const name{"AsmElfSymverNeededAuxList"};
5110 static constexpr unsigned long variant{182};
5111 static constexpr bool concrete{true};
5112 using subclasses_t = mp::List<>;
5114};
5115template <> struct node_from_variant_t<182> { using type = SgAsmElfSymverNeededAuxList; };
5116
5117// Class: AsmElfSymverNeededEntry
5118template <> struct describe_field_t<SgAsmElfSymverNeededEntry,size_t,&SgAsmElfSymverNeededEntry::p_version> {
5120 using field_type = size_t;
5121 static constexpr size_t position{0};
5122 static constexpr char const * const name{"version"};
5123 static constexpr char const * const typestr{"size_t"};
5124 static constexpr bool traverse{false};
5125 static constexpr auto mbr_ptr{&SgAsmElfSymverNeededEntry::p_version};
5126 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5127 using bind = Desc<SgAsmElfSymverNeededEntry, size_t SgAsmElfSymverNeededEntry::*, &SgAsmElfSymverNeededEntry::p_version>;
5128};
5129template <> struct describe_field_t<SgAsmElfSymverNeededEntry,SgAsmGenericString*,&SgAsmElfSymverNeededEntry::p_fileName> {
5132 static constexpr size_t position{1};
5133 static constexpr char const * const name{"fileName"};
5134 static constexpr char const * const typestr{"SgAsmGenericString*"};
5135 static constexpr bool traverse{true};
5136 static constexpr auto mbr_ptr{&SgAsmElfSymverNeededEntry::p_fileName};
5137 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5138 using bind = Desc<SgAsmElfSymverNeededEntry, SgAsmGenericString* SgAsmElfSymverNeededEntry::*, &SgAsmElfSymverNeededEntry::p_fileName>;
5139};
5140template <> struct describe_field_t<SgAsmElfSymverNeededEntry,SgAsmElfSymverNeededAuxList*,&SgAsmElfSymverNeededEntry::p_entries> {
5143 static constexpr size_t position{2};
5144 static constexpr char const * const name{"entries"};
5145 static constexpr char const * const typestr{"SgAsmElfSymverNeededAuxList*"};
5146 static constexpr bool traverse{true};
5147 static constexpr auto mbr_ptr{&SgAsmElfSymverNeededEntry::p_entries};
5148 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5149 using bind = Desc<SgAsmElfSymverNeededEntry, SgAsmElfSymverNeededAuxList* SgAsmElfSymverNeededEntry::*, &SgAsmElfSymverNeededEntry::p_entries>;
5150};
5160template <> struct node_from_variant_t<183> { using type = SgAsmElfSymverNeededEntry; };
5161
5162// Class: AsmElfSymverNeededEntryList
5163template <> struct describe_field_t<SgAsmElfSymverNeededEntryList,SgAsmElfSymverNeededEntryPtrList,&SgAsmElfSymverNeededEntryList::p_entries> {
5165 using field_type = SgAsmElfSymverNeededEntryPtrList;
5166 static constexpr size_t position{0};
5167 static constexpr char const * const name{"entries"};
5168 static constexpr char const * const typestr{"SgAsmElfSymverNeededEntryPtrList"};
5169 static constexpr bool traverse{true};
5170 static constexpr auto mbr_ptr{&SgAsmElfSymverNeededEntryList::p_entries};
5171 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5172 using bind = Desc<SgAsmElfSymverNeededEntryList, SgAsmElfSymverNeededEntryPtrList SgAsmElfSymverNeededEntryList::*, &SgAsmElfSymverNeededEntryList::p_entries>;
5173};
5177 static constexpr char const * const name{"AsmElfSymverNeededEntryList"};
5178 static constexpr unsigned long variant{184};
5179 static constexpr bool concrete{true};
5180 using subclasses_t = mp::List<>;
5182};
5183template <> struct node_from_variant_t<184> { using type = SgAsmElfSymverNeededEntryList; };
5184
5185// Class: AsmElfSymverNeededSection
5186template <> struct describe_field_t<SgAsmElfSymverNeededSection,SgAsmElfSymverNeededEntryList*,&SgAsmElfSymverNeededSection::p_entries> {
5189 static constexpr size_t position{0};
5190 static constexpr char const * const name{"entries"};
5191 static constexpr char const * const typestr{"SgAsmElfSymverNeededEntryList*"};
5192 static constexpr bool traverse{true};
5193 static constexpr auto mbr_ptr{&SgAsmElfSymverNeededSection::p_entries};
5194 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5195 using bind = Desc<SgAsmElfSymverNeededSection, SgAsmElfSymverNeededEntryList* SgAsmElfSymverNeededSection::*, &SgAsmElfSymverNeededSection::p_entries>;
5196};
5199 using base = SgAsmElfSection;
5200 static constexpr char const * const name{"AsmElfSymverNeededSection"};
5201 static constexpr unsigned long variant{185};
5202 static constexpr bool concrete{true};
5203 using subclasses_t = mp::List<>;
5205};
5206template <> struct node_from_variant_t<185> { using type = SgAsmElfSymverNeededSection; };
5207
5208// Class: AsmElfSymverSection
5209template <> struct describe_field_t<SgAsmElfSymverSection,SgAsmElfSymverEntryList*,&SgAsmElfSymverSection::p_entries> {
5212 static constexpr size_t position{0};
5213 static constexpr char const * const name{"entries"};
5214 static constexpr char const * const typestr{"SgAsmElfSymverEntryList*"};
5215 static constexpr bool traverse{true};
5216 static constexpr auto mbr_ptr{&SgAsmElfSymverSection::p_entries};
5217 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5218 using bind = Desc<SgAsmElfSymverSection, SgAsmElfSymverEntryList* SgAsmElfSymverSection::*, &SgAsmElfSymverSection::p_entries>;
5219};
5222 using base = SgAsmElfSection;
5223 static constexpr char const * const name{"AsmElfSymverSection"};
5224 static constexpr unsigned long variant{186};
5225 static constexpr bool concrete{true};
5226 using subclasses_t = mp::List<>;
5228};
5229template <> struct node_from_variant_t<186> { using type = SgAsmElfSymverSection; };
5230
5231// Class: AsmExecutableFileFormat
5234 using base = SgAsmNode;
5235 static constexpr char const * const name{"AsmExecutableFileFormat"};
5236 static constexpr unsigned long variant{187};
5237 static constexpr bool concrete{false};
5239 using fields_t = mp::List<>;
5240};
5241template <> struct node_from_variant_t<187> { using type = SgAsmExecutableFileFormat; };
5242
5243// Class: AsmExprListExp
5244template <> struct describe_field_t<SgAsmExprListExp,SgAsmExpressionPtrList,&SgAsmExprListExp::p_expressions> {
5245 using parent = SgAsmExprListExp;
5246 using field_type = SgAsmExpressionPtrList;
5247 static constexpr size_t position{0};
5248 static constexpr char const * const name{"expressions"};
5249 static constexpr char const * const typestr{"SgAsmExpressionPtrList"};
5250 static constexpr bool traverse{true};
5251 static constexpr auto mbr_ptr{&SgAsmExprListExp::p_expressions};
5252 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5253 using bind = Desc<SgAsmExprListExp, SgAsmExpressionPtrList SgAsmExprListExp::*, &SgAsmExprListExp::p_expressions>;
5254};
5256 using node = SgAsmExprListExp;
5257 using base = SgAsmExpression;
5258 static constexpr char const * const name{"AsmExprListExp"};
5259 static constexpr unsigned long variant{188};
5260 static constexpr bool concrete{true};
5261 using subclasses_t = mp::List<>;
5263};
5264template <> struct node_from_variant_t<188> { using type = SgAsmExprListExp; };
5265
5266// Class: AsmExpression
5267template <> struct describe_field_t<SgAsmExpression,SgAsmType*,&SgAsmExpression::p_type> {
5268 using parent = SgAsmExpression;
5269 using field_type = SgAsmType*;
5270 static constexpr size_t position{0};
5271 static constexpr char const * const name{"type"};
5272 static constexpr char const * const typestr{"SgAsmType*"};
5273 static constexpr bool traverse{false};
5274 static constexpr auto mbr_ptr{&SgAsmExpression::p_type};
5275 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5276 using bind = Desc<SgAsmExpression, SgAsmType* SgAsmExpression::*, &SgAsmExpression::p_type>;
5277};
5278template <> struct describe_field_t<SgAsmExpression,std::string,&SgAsmExpression::p_comment> {
5279 using parent = SgAsmExpression;
5280 using field_type = std::string;
5281 static constexpr size_t position{1};
5282 static constexpr char const * const name{"comment"};
5283 static constexpr char const * const typestr{"std::string"};
5284 static constexpr bool traverse{false};
5285 static constexpr auto mbr_ptr{&SgAsmExpression::p_comment};
5286 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5287 using bind = Desc<SgAsmExpression, std::string SgAsmExpression::*, &SgAsmExpression::p_comment>;
5288};
5298template <> struct node_from_variant_t<189> { using type = SgAsmExpression; };
5299
5300// Class: AsmSynthesizedFieldDeclaration
5301template <> struct describe_field_t<SgAsmSynthesizedFieldDeclaration,std::string,&SgAsmSynthesizedFieldDeclaration::p_name> {
5303 using field_type = std::string;
5304 static constexpr size_t position{0};
5305 static constexpr char const * const name{"name"};
5306 static constexpr char const * const typestr{"std::string"};
5307 static constexpr bool traverse{false};
5308 static constexpr auto mbr_ptr{&SgAsmSynthesizedFieldDeclaration::p_name};
5309 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5310 using bind = Desc<SgAsmSynthesizedFieldDeclaration, std::string SgAsmSynthesizedFieldDeclaration::*, &SgAsmSynthesizedFieldDeclaration::p_name>;
5311};
5312template <> struct describe_field_t<SgAsmSynthesizedFieldDeclaration,uint64_t,&SgAsmSynthesizedFieldDeclaration::p_offset> {
5314 using field_type = uint64_t;
5315 static constexpr size_t position{1};
5316 static constexpr char const * const name{"offset"};
5317 static constexpr char const * const typestr{"uint64_t"};
5318 static constexpr bool traverse{false};
5319 static constexpr auto mbr_ptr{&SgAsmSynthesizedFieldDeclaration::p_offset};
5320 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5321 using bind = Desc<SgAsmSynthesizedFieldDeclaration, uint64_t SgAsmSynthesizedFieldDeclaration::*, &SgAsmSynthesizedFieldDeclaration::p_offset>;
5322};
5326 static constexpr char const * const name{"AsmSynthesizedFieldDeclaration"};
5327 static constexpr unsigned long variant{190};
5328 static constexpr bool concrete{true};
5329 using subclasses_t = mp::List<>;
5331};
5332template <> struct node_from_variant_t<190> { using type = SgAsmSynthesizedFieldDeclaration; };
5333
5334// Class: AsmFloatType
5335template <> struct describe_field_t<SgAsmFloatType,size_t,&SgAsmFloatType::p_significandOffset> {
5336 using parent = SgAsmFloatType;
5337 using field_type = size_t;
5338 static constexpr size_t position{0};
5339 static constexpr char const * const name{"significandOffset"};
5340 static constexpr char const * const typestr{"size_t"};
5341 static constexpr bool traverse{false};
5342 static constexpr auto mbr_ptr{&SgAsmFloatType::p_significandOffset};
5343 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5344 using bind = Desc<SgAsmFloatType, size_t SgAsmFloatType::*, &SgAsmFloatType::p_significandOffset>;
5345};
5346template <> struct describe_field_t<SgAsmFloatType,size_t,&SgAsmFloatType::p_significandNBits> {
5347 using parent = SgAsmFloatType;
5348 using field_type = size_t;
5349 static constexpr size_t position{1};
5350 static constexpr char const * const name{"significandNBits"};
5351 static constexpr char const * const typestr{"size_t"};
5352 static constexpr bool traverse{false};
5353 static constexpr auto mbr_ptr{&SgAsmFloatType::p_significandNBits};
5354 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5355 using bind = Desc<SgAsmFloatType, size_t SgAsmFloatType::*, &SgAsmFloatType::p_significandNBits>;
5356};
5357template <> struct describe_field_t<SgAsmFloatType,size_t,&SgAsmFloatType::p_signBitOffset> {
5358 using parent = SgAsmFloatType;
5359 using field_type = size_t;
5360 static constexpr size_t position{2};
5361 static constexpr char const * const name{"signBitOffset"};
5362 static constexpr char const * const typestr{"size_t"};
5363 static constexpr bool traverse{false};
5364 static constexpr auto mbr_ptr{&SgAsmFloatType::p_signBitOffset};
5365 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5366 using bind = Desc<SgAsmFloatType, size_t SgAsmFloatType::*, &SgAsmFloatType::p_signBitOffset>;
5367};
5368template <> struct describe_field_t<SgAsmFloatType,size_t,&SgAsmFloatType::p_exponentOffset> {
5369 using parent = SgAsmFloatType;
5370 using field_type = size_t;
5371 static constexpr size_t position{3};
5372 static constexpr char const * const name{"exponentOffset"};
5373 static constexpr char const * const typestr{"size_t"};
5374 static constexpr bool traverse{false};
5375 static constexpr auto mbr_ptr{&SgAsmFloatType::p_exponentOffset};
5376 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5377 using bind = Desc<SgAsmFloatType, size_t SgAsmFloatType::*, &SgAsmFloatType::p_exponentOffset>;
5378};
5379template <> struct describe_field_t<SgAsmFloatType,size_t,&SgAsmFloatType::p_exponentNBits> {
5380 using parent = SgAsmFloatType;
5381 using field_type = size_t;
5382 static constexpr size_t position{4};
5383 static constexpr char const * const name{"exponentNBits"};
5384 static constexpr char const * const typestr{"size_t"};
5385 static constexpr bool traverse{false};
5386 static constexpr auto mbr_ptr{&SgAsmFloatType::p_exponentNBits};
5387 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5388 using bind = Desc<SgAsmFloatType, size_t SgAsmFloatType::*, &SgAsmFloatType::p_exponentNBits>;
5389};
5390template <> struct describe_field_t<SgAsmFloatType,uint64_t,&SgAsmFloatType::p_exponentBias> {
5391 using parent = SgAsmFloatType;
5392 using field_type = uint64_t;
5393 static constexpr size_t position{5};
5394 static constexpr char const * const name{"exponentBias"};
5395 static constexpr char const * const typestr{"uint64_t"};
5396 static constexpr bool traverse{false};
5397 static constexpr auto mbr_ptr{&SgAsmFloatType::p_exponentBias};
5398 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5399 using bind = Desc<SgAsmFloatType, uint64_t SgAsmFloatType::*, &SgAsmFloatType::p_exponentBias>;
5400};
5401template <> struct describe_field_t<SgAsmFloatType,unsigned,&SgAsmFloatType::p_flags> {
5402 using parent = SgAsmFloatType;
5403 using field_type = unsigned;
5404 static constexpr size_t position{6};
5405 static constexpr char const * const name{"flags"};
5406 static constexpr char const * const typestr{"unsigned"};
5407 static constexpr bool traverse{false};
5408 static constexpr auto mbr_ptr{&SgAsmFloatType::p_flags};
5409 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5410 using bind = Desc<SgAsmFloatType, unsigned SgAsmFloatType::*, &SgAsmFloatType::p_flags>;
5411};
5421template <> struct node_from_variant_t<191> { using type = SgAsmFloatType; };
5422
5423// Class: AsmFloatValueExpression
5427 static constexpr char const * const name{"AsmFloatValueExpression"};
5428 static constexpr unsigned long variant{192};
5429 static constexpr bool concrete{true};
5430 using subclasses_t = mp::List<>;
5431 using fields_t = mp::List<>;
5432};
5433template <> struct node_from_variant_t<192> { using type = SgAsmFloatValueExpression; };
5434
5435// Class: AsmFunction
5436template <> struct describe_field_t<SgAsmFunction,std::string,&SgAsmFunction::p_name> {
5437 using parent = SgAsmFunction;
5438 using field_type = std::string;
5439 static constexpr size_t position{0};
5440 static constexpr char const * const name{"name"};
5441 static constexpr char const * const typestr{"std::string"};
5442 static constexpr bool traverse{false};
5443 static constexpr auto mbr_ptr{&SgAsmFunction::p_name};
5444 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5445 using bind = Desc<SgAsmFunction, std::string SgAsmFunction::*, &SgAsmFunction::p_name>;
5446};
5447template <> struct describe_field_t<SgAsmFunction,unsigned,&SgAsmFunction::p_reason> {
5448 using parent = SgAsmFunction;
5449 using field_type = unsigned;
5450 static constexpr size_t position{1};
5451 static constexpr char const * const name{"reason"};
5452 static constexpr char const * const typestr{"unsigned"};
5453 static constexpr bool traverse{false};
5454 static constexpr auto mbr_ptr{&SgAsmFunction::p_reason};
5455 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5456 using bind = Desc<SgAsmFunction, unsigned SgAsmFunction::*, &SgAsmFunction::p_reason>;
5457};
5458template <> struct describe_field_t<SgAsmFunction,std::string,&SgAsmFunction::p_reasonComment> {
5459 using parent = SgAsmFunction;
5460 using field_type = std::string;
5461 static constexpr size_t position{2};
5462 static constexpr char const * const name{"reasonComment"};
5463 static constexpr char const * const typestr{"std::string"};
5464 static constexpr bool traverse{false};
5465 static constexpr auto mbr_ptr{&SgAsmFunction::p_reasonComment};
5466 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5467 using bind = Desc<SgAsmFunction, std::string SgAsmFunction::*, &SgAsmFunction::p_reasonComment>;
5468};
5469template <> struct describe_field_t<SgAsmFunction,SgAsmFunction::function_kind_enum,&SgAsmFunction::p_functionKind> {
5470 using parent = SgAsmFunction;
5472 static constexpr size_t position{3};
5473 static constexpr char const * const name{"functionKind"};
5474 static constexpr char const * const typestr{"SgAsmFunction::function_kind_enum"};
5475 static constexpr bool traverse{false};
5476 static constexpr auto mbr_ptr{&SgAsmFunction::p_functionKind};
5477 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5478 using bind = Desc<SgAsmFunction, SgAsmFunction::function_kind_enum SgAsmFunction::*, &SgAsmFunction::p_functionKind>;
5479};
5480template <> struct describe_field_t<SgAsmFunction,SgAsmFunction::MayReturn,&SgAsmFunction::p_mayReturn> {
5481 using parent = SgAsmFunction;
5483 static constexpr size_t position{4};
5484 static constexpr char const * const name{"mayReturn"};
5485 static constexpr char const * const typestr{"SgAsmFunction::MayReturn"};
5486 static constexpr bool traverse{false};
5487 static constexpr auto mbr_ptr{&SgAsmFunction::p_mayReturn};
5488 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5489 using bind = Desc<SgAsmFunction, SgAsmFunction::MayReturn SgAsmFunction::*, &SgAsmFunction::p_mayReturn>;
5490};
5491template <> struct describe_field_t<SgAsmFunction,std::string,&SgAsmFunction::p_nameMd5> {
5492 using parent = SgAsmFunction;
5493 using field_type = std::string;
5494 static constexpr size_t position{5};
5495 static constexpr char const * const name{"nameMd5"};
5496 static constexpr char const * const typestr{"std::string"};
5497 static constexpr bool traverse{false};
5498 static constexpr auto mbr_ptr{&SgAsmFunction::p_nameMd5};
5499 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5500 using bind = Desc<SgAsmFunction, std::string SgAsmFunction::*, &SgAsmFunction::p_nameMd5>;
5501};
5502template <> struct describe_field_t<SgAsmFunction,SgAsmStatementPtrList,&SgAsmFunction::p_statementList> {
5503 using parent = SgAsmFunction;
5504 using field_type = SgAsmStatementPtrList;
5505 static constexpr size_t position{6};
5506 static constexpr char const * const name{"statementList"};
5507 static constexpr char const * const typestr{"SgAsmStatementPtrList"};
5508 static constexpr bool traverse{true};
5509 static constexpr auto mbr_ptr{&SgAsmFunction::p_statementList};
5510 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5511 using bind = Desc<SgAsmFunction, SgAsmStatementPtrList SgAsmFunction::*, &SgAsmFunction::p_statementList>;
5512};
5513template <> struct describe_field_t<SgAsmFunction,SgAsmStatementPtrList,&SgAsmFunction::p_dest> {
5514 using parent = SgAsmFunction;
5515 using field_type = SgAsmStatementPtrList;
5516 static constexpr size_t position{7};
5517 static constexpr char const * const name{"dest"};
5518 static constexpr char const * const typestr{"SgAsmStatementPtrList"};
5519 static constexpr bool traverse{false};
5520 static constexpr auto mbr_ptr{&SgAsmFunction::p_dest};
5521 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5522 using bind = Desc<SgAsmFunction, SgAsmStatementPtrList SgAsmFunction::*, &SgAsmFunction::p_dest>;
5523};
5524template <> struct describe_field_t<SgAsmFunction,Rose::BinaryAnalysis::Address,&SgAsmFunction::p_entryVa> {
5525 using parent = SgAsmFunction;
5526 using field_type = Rose::BinaryAnalysis::Address;
5527 static constexpr size_t position{8};
5528 static constexpr char const * const name{"entryVa"};
5529 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
5530 static constexpr bool traverse{false};
5531 static constexpr auto mbr_ptr{&SgAsmFunction::p_entryVa};
5532 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5533 using bind = Desc<SgAsmFunction, Rose::BinaryAnalysis::Address SgAsmFunction::*, &SgAsmFunction::p_entryVa>;
5534};
5535template <> struct describe_field_t<SgAsmFunction,SgSymbolTable*,&SgAsmFunction::p_symbolTable> {
5536 using parent = SgAsmFunction;
5537 using field_type = SgSymbolTable*;
5538 static constexpr size_t position{9};
5539 static constexpr char const * const name{"symbolTable"};
5540 static constexpr char const * const typestr{"SgSymbolTable*"};
5541 static constexpr bool traverse{false};
5542 static constexpr auto mbr_ptr{&SgAsmFunction::p_symbolTable};
5543 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5544 using bind = Desc<SgAsmFunction, SgSymbolTable* SgAsmFunction::*, &SgAsmFunction::p_symbolTable>;
5545};
5546template <> struct describe_field_t<SgAsmFunction,size_t,&SgAsmFunction::p_cachedVertex> {
5547 using parent = SgAsmFunction;
5548 using field_type = size_t;
5549 static constexpr size_t position{10};
5550 static constexpr char const * const name{"cachedVertex"};
5551 static constexpr char const * const typestr{"size_t"};
5552 static constexpr bool traverse{false};
5553 static constexpr auto mbr_ptr{&SgAsmFunction::p_cachedVertex};
5554 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5555 using bind = Desc<SgAsmFunction, size_t SgAsmFunction::*, &SgAsmFunction::p_cachedVertex>;
5556};
5557template <> struct describe_field_t<SgAsmFunction,int64_t,&SgAsmFunction::p_stackDelta> {
5558 using parent = SgAsmFunction;
5559 using field_type = int64_t;
5560 static constexpr size_t position{11};
5561 static constexpr char const * const name{"stackDelta"};
5562 static constexpr char const * const typestr{"int64_t"};
5563 static constexpr bool traverse{false};
5564 static constexpr auto mbr_ptr{&SgAsmFunction::p_stackDelta};
5565 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5566 using bind = Desc<SgAsmFunction, int64_t SgAsmFunction::*, &SgAsmFunction::p_stackDelta>;
5567};
5568template <> struct describe_field_t<SgAsmFunction,std::string,&SgAsmFunction::p_callingConvention> {
5569 using parent = SgAsmFunction;
5570 using field_type = std::string;
5571 static constexpr size_t position{12};
5572 static constexpr char const * const name{"callingConvention"};
5573 static constexpr char const * const typestr{"std::string"};
5574 static constexpr bool traverse{false};
5575 static constexpr auto mbr_ptr{&SgAsmFunction::p_callingConvention};
5576 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5577 using bind = Desc<SgAsmFunction, std::string SgAsmFunction::*, &SgAsmFunction::p_callingConvention>;
5578};
5588template <> struct node_from_variant_t<193> { using type = SgAsmFunction; };
5589
5590// Class: AsmGenericDLL
5591template <> struct describe_field_t<SgAsmGenericDLL,SgAsmGenericString*,&SgAsmGenericDLL::p_name> {
5592 using parent = SgAsmGenericDLL;
5594 static constexpr size_t position{0};
5595 static constexpr char const * const name{"name"};
5596 static constexpr char const * const typestr{"SgAsmGenericString*"};
5597 static constexpr bool traverse{true};
5598 static constexpr auto mbr_ptr{&SgAsmGenericDLL::p_name};
5599 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5600 using bind = Desc<SgAsmGenericDLL, SgAsmGenericString* SgAsmGenericDLL::*, &SgAsmGenericDLL::p_name>;
5601};
5602template <> struct describe_field_t<SgAsmGenericDLL,SgStringList,&SgAsmGenericDLL::p_symbols> {
5603 using parent = SgAsmGenericDLL;
5604 using field_type = SgStringList;
5605 static constexpr size_t position{1};
5606 static constexpr char const * const name{"symbols"};
5607 static constexpr char const * const typestr{"SgStringList"};
5608 static constexpr bool traverse{false};
5609 static constexpr auto mbr_ptr{&SgAsmGenericDLL::p_symbols};
5610 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5611 using bind = Desc<SgAsmGenericDLL, SgStringList SgAsmGenericDLL::*, &SgAsmGenericDLL::p_symbols>;
5612};
5614 using node = SgAsmGenericDLL;
5616 static constexpr char const * const name{"AsmGenericDLL"};
5617 static constexpr unsigned long variant{194};
5618 static constexpr bool concrete{true};
5619 using subclasses_t = mp::List<>;
5621};
5622template <> struct node_from_variant_t<194> { using type = SgAsmGenericDLL; };
5623
5624// Class: AsmGenericDLLList
5625template <> struct describe_field_t<SgAsmGenericDLLList,SgAsmGenericDLLPtrList,&SgAsmGenericDLLList::p_dlls> {
5627 using field_type = SgAsmGenericDLLPtrList;
5628 static constexpr size_t position{0};
5629 static constexpr char const * const name{"dlls"};
5630 static constexpr char const * const typestr{"SgAsmGenericDLLPtrList"};
5631 static constexpr bool traverse{false};
5632 static constexpr auto mbr_ptr{&SgAsmGenericDLLList::p_dlls};
5633 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5634 using bind = Desc<SgAsmGenericDLLList, SgAsmGenericDLLPtrList SgAsmGenericDLLList::*, &SgAsmGenericDLLList::p_dlls>;
5635};
5637 using node = SgAsmGenericDLLList;
5639 static constexpr char const * const name{"AsmGenericDLLList"};
5640 static constexpr unsigned long variant{195};
5641 static constexpr bool concrete{true};
5642 using subclasses_t = mp::List<>;
5644};
5645template <> struct node_from_variant_t<195> { using type = SgAsmGenericDLLList; };
5646
5647// Class: AsmGenericFile
5648template <> struct describe_field_t<SgAsmGenericFile,SgAsmDwarfCompilationUnitList*,&SgAsmGenericFile::p_dwarfInfo> {
5649 using parent = SgAsmGenericFile;
5651 static constexpr size_t position{0};
5652 static constexpr char const * const name{"dwarfInfo"};
5653 static constexpr char const * const typestr{"SgAsmDwarfCompilationUnitList*"};
5654 static constexpr bool traverse{true};
5655 static constexpr auto mbr_ptr{&SgAsmGenericFile::p_dwarfInfo};
5656 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5657 using bind = Desc<SgAsmGenericFile, SgAsmDwarfCompilationUnitList* SgAsmGenericFile::*, &SgAsmGenericFile::p_dwarfInfo>;
5658};
5659template <> struct describe_field_t<SgAsmGenericFile,std::string,&SgAsmGenericFile::p_name> {
5660 using parent = SgAsmGenericFile;
5661 using field_type = std::string;
5662 static constexpr size_t position{1};
5663 static constexpr char const * const name{"name"};
5664 static constexpr char const * const typestr{"std::string"};
5665 static constexpr bool traverse{false};
5666 static constexpr auto mbr_ptr{&SgAsmGenericFile::p_name};
5667 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5668 using bind = Desc<SgAsmGenericFile, std::string SgAsmGenericFile::*, &SgAsmGenericFile::p_name>;
5669};
5670template <> struct describe_field_t<SgAsmGenericFile,int,&SgAsmGenericFile::p_fd> {
5671 using parent = SgAsmGenericFile;
5672 using field_type = int;
5673 static constexpr size_t position{2};
5674 static constexpr char const * const name{"fd"};
5675 static constexpr char const * const typestr{"int"};
5676 static constexpr bool traverse{false};
5677 static constexpr auto mbr_ptr{&SgAsmGenericFile::p_fd};
5678 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5679 using bind = Desc<SgAsmGenericFile, int SgAsmGenericFile::*, &SgAsmGenericFile::p_fd>;
5680};
5681template <> struct describe_field_t<SgAsmGenericFile,struct stat,&SgAsmGenericFile::p_sb> {
5682 using parent = SgAsmGenericFile;
5683 using field_type = struct stat;
5684 static constexpr size_t position{3};
5685 static constexpr char const * const name{"sb"};
5686 static constexpr char const * const typestr{"struct stat"};
5687 static constexpr bool traverse{false};
5688 static constexpr auto mbr_ptr{&SgAsmGenericFile::p_sb};
5689 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5690 using bind = Desc<SgAsmGenericFile, struct stat SgAsmGenericFile::*, &SgAsmGenericFile::p_sb>;
5691};
5692template <> struct describe_field_t<SgAsmGenericFile,SgFileContentList,&SgAsmGenericFile::p_data> {
5693 using parent = SgAsmGenericFile;
5695 static constexpr size_t position{4};
5696 static constexpr char const * const name{"data"};
5697 static constexpr char const * const typestr{"SgFileContentList"};
5698 static constexpr bool traverse{false};
5699 static constexpr auto mbr_ptr{&SgAsmGenericFile::p_data};
5700 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5701 using bind = Desc<SgAsmGenericFile, SgFileContentList SgAsmGenericFile::*, &SgAsmGenericFile::p_data>;
5702};
5703template <> struct describe_field_t<SgAsmGenericFile,SgAsmGenericHeaderList*,&SgAsmGenericFile::p_headers> {
5704 using parent = SgAsmGenericFile;
5706 static constexpr size_t position{5};
5707 static constexpr char const * const name{"headers"};
5708 static constexpr char const * const typestr{"SgAsmGenericHeaderList*"};
5709 static constexpr bool traverse{true};
5710 static constexpr auto mbr_ptr{&SgAsmGenericFile::p_headers};
5711 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5712 using bind = Desc<SgAsmGenericFile, SgAsmGenericHeaderList* SgAsmGenericFile::*, &SgAsmGenericFile::p_headers>;
5713};
5714template <> struct describe_field_t<SgAsmGenericFile,SgAsmGenericSectionList*,&SgAsmGenericFile::p_holes> {
5715 using parent = SgAsmGenericFile;
5717 static constexpr size_t position{6};
5718 static constexpr char const * const name{"holes"};
5719 static constexpr char const * const typestr{"SgAsmGenericSectionList*"};
5720 static constexpr bool traverse{true};
5721 static constexpr auto mbr_ptr{&SgAsmGenericFile::p_holes};
5722 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5723 using bind = Desc<SgAsmGenericFile, SgAsmGenericSectionList* SgAsmGenericFile::*, &SgAsmGenericFile::p_holes>;
5724};
5725template <> struct describe_field_t<SgAsmGenericFile,bool,&SgAsmGenericFile::p_truncateZeros> {
5726 using parent = SgAsmGenericFile;
5727 using field_type = bool;
5728 static constexpr size_t position{7};
5729 static constexpr char const * const name{"truncateZeros"};
5730 static constexpr char const * const typestr{"bool"};
5731 static constexpr bool traverse{false};
5732 static constexpr auto mbr_ptr{&SgAsmGenericFile::p_truncateZeros};
5733 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5734 using bind = Desc<SgAsmGenericFile, bool SgAsmGenericFile::*, &SgAsmGenericFile::p_truncateZeros>;
5735};
5736template <> struct describe_field_t<SgAsmGenericFile,bool,&SgAsmGenericFile::p_trackingReferences> {
5737 using parent = SgAsmGenericFile;
5738 using field_type = bool;
5739 static constexpr size_t position{8};
5740 static constexpr char const * const name{"trackingReferences"};
5741 static constexpr char const * const typestr{"bool"};
5742 static constexpr bool traverse{false};
5743 static constexpr auto mbr_ptr{&SgAsmGenericFile::p_trackingReferences};
5744 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5745 using bind = Desc<SgAsmGenericFile, bool SgAsmGenericFile::*, &SgAsmGenericFile::p_trackingReferences>;
5746};
5747template <> struct describe_field_t<SgAsmGenericFile,Rose::BinaryAnalysis::AddressIntervalSet,&SgAsmGenericFile::p_referencedExtents> {
5748 using parent = SgAsmGenericFile;
5750 static constexpr size_t position{9};
5751 static constexpr char const * const name{"referencedExtents"};
5752 static constexpr char const * const typestr{"Rose::BinaryAnalysis::AddressIntervalSet"};
5753 static constexpr bool traverse{false};
5754 static constexpr auto mbr_ptr{&SgAsmGenericFile::p_referencedExtents};
5755 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5756 using bind = Desc<SgAsmGenericFile, Rose::BinaryAnalysis::AddressIntervalSet SgAsmGenericFile::*, &SgAsmGenericFile::p_referencedExtents>;
5757};
5758template <> struct describe_field_t<SgAsmGenericFile,bool,&SgAsmGenericFile::p_neuter> {
5759 using parent = SgAsmGenericFile;
5760 using field_type = bool;
5761 static constexpr size_t position{10};
5762 static constexpr char const * const name{"neuter"};
5763 static constexpr char const * const typestr{"bool"};
5764 static constexpr bool traverse{false};
5765 static constexpr auto mbr_ptr{&SgAsmGenericFile::p_neuter};
5766 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5767 using bind = Desc<SgAsmGenericFile, bool SgAsmGenericFile::*, &SgAsmGenericFile::p_neuter>;
5768};
5778template <> struct node_from_variant_t<196> { using type = SgAsmGenericFile; };
5779
5780// Class: AsmGenericFileList
5781template <> struct describe_field_t<SgAsmGenericFileList,SgAsmGenericFilePtrList,&SgAsmGenericFileList::p_files> {
5783 using field_type = SgAsmGenericFilePtrList;
5784 static constexpr size_t position{0};
5785 static constexpr char const * const name{"files"};
5786 static constexpr char const * const typestr{"SgAsmGenericFilePtrList"};
5787 static constexpr bool traverse{true};
5788 static constexpr auto mbr_ptr{&SgAsmGenericFileList::p_files};
5789 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5790 using bind = Desc<SgAsmGenericFileList, SgAsmGenericFilePtrList SgAsmGenericFileList::*, &SgAsmGenericFileList::p_files>;
5791};
5793 using node = SgAsmGenericFileList;
5794 using base = SgAsmNode;
5795 static constexpr char const * const name{"AsmGenericFileList"};
5796 static constexpr unsigned long variant{197};
5797 static constexpr bool concrete{true};
5798 using subclasses_t = mp::List<>;
5800};
5801template <> struct node_from_variant_t<197> { using type = SgAsmGenericFileList; };
5802
5803// Class: AsmGenericFormat
5804template <> struct describe_field_t<SgAsmGenericFormat,SgAsmGenericFormat::ExecFamily,&SgAsmGenericFormat::p_family> {
5805 using parent = SgAsmGenericFormat;
5807 static constexpr size_t position{0};
5808 static constexpr char const * const name{"family"};
5809 static constexpr char const * const typestr{"SgAsmGenericFormat::ExecFamily"};
5810 static constexpr bool traverse{false};
5811 static constexpr auto mbr_ptr{&SgAsmGenericFormat::p_family};
5812 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5813 using bind = Desc<SgAsmGenericFormat, SgAsmGenericFormat::ExecFamily SgAsmGenericFormat::*, &SgAsmGenericFormat::p_family>;
5814};
5815template <> struct describe_field_t<SgAsmGenericFormat,SgAsmGenericFormat::ExecPurpose,&SgAsmGenericFormat::p_purpose> {
5816 using parent = SgAsmGenericFormat;
5818 static constexpr size_t position{1};
5819 static constexpr char const * const name{"purpose"};
5820 static constexpr char const * const typestr{"SgAsmGenericFormat::ExecPurpose"};
5821 static constexpr bool traverse{false};
5822 static constexpr auto mbr_ptr{&SgAsmGenericFormat::p_purpose};
5823 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5824 using bind = Desc<SgAsmGenericFormat, SgAsmGenericFormat::ExecPurpose SgAsmGenericFormat::*, &SgAsmGenericFormat::p_purpose>;
5825};
5827 using parent = SgAsmGenericFormat;
5829 static constexpr size_t position{2};
5830 static constexpr char const * const name{"sex"};
5831 static constexpr char const * const typestr{"Rose::BinaryAnalysis::ByteOrder::Endianness"};
5832 static constexpr bool traverse{false};
5833 static constexpr auto mbr_ptr{&SgAsmGenericFormat::p_sex};
5834 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5835 using bind = Desc<SgAsmGenericFormat, Rose::BinaryAnalysis::ByteOrder::Endianness SgAsmGenericFormat::*, &SgAsmGenericFormat::p_sex>;
5836};
5837template <> struct describe_field_t<SgAsmGenericFormat,unsigned,&SgAsmGenericFormat::p_version> {
5838 using parent = SgAsmGenericFormat;
5839 using field_type = unsigned;
5840 static constexpr size_t position{3};
5841 static constexpr char const * const name{"version"};
5842 static constexpr char const * const typestr{"unsigned"};
5843 static constexpr bool traverse{false};
5844 static constexpr auto mbr_ptr{&SgAsmGenericFormat::p_version};
5845 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5846 using bind = Desc<SgAsmGenericFormat, unsigned SgAsmGenericFormat::*, &SgAsmGenericFormat::p_version>;
5847};
5848template <> struct describe_field_t<SgAsmGenericFormat,bool,&SgAsmGenericFormat::p_isCurrentVersion> {
5849 using parent = SgAsmGenericFormat;
5850 using field_type = bool;
5851 static constexpr size_t position{4};
5852 static constexpr char const * const name{"isCurrentVersion"};
5853 static constexpr char const * const typestr{"bool"};
5854 static constexpr bool traverse{false};
5855 static constexpr auto mbr_ptr{&SgAsmGenericFormat::p_isCurrentVersion};
5856 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5857 using bind = Desc<SgAsmGenericFormat, bool SgAsmGenericFormat::*, &SgAsmGenericFormat::p_isCurrentVersion>;
5858};
5859template <> struct describe_field_t<SgAsmGenericFormat,SgAsmGenericFormat::ExecABI,&SgAsmGenericFormat::p_abi> {
5860 using parent = SgAsmGenericFormat;
5862 static constexpr size_t position{5};
5863 static constexpr char const * const name{"abi"};
5864 static constexpr char const * const typestr{"SgAsmGenericFormat::ExecABI"};
5865 static constexpr bool traverse{false};
5866 static constexpr auto mbr_ptr{&SgAsmGenericFormat::p_abi};
5867 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5868 using bind = Desc<SgAsmGenericFormat, SgAsmGenericFormat::ExecABI SgAsmGenericFormat::*, &SgAsmGenericFormat::p_abi>;
5869};
5870template <> struct describe_field_t<SgAsmGenericFormat,unsigned,&SgAsmGenericFormat::p_abiVersion> {
5871 using parent = SgAsmGenericFormat;
5872 using field_type = unsigned;
5873 static constexpr size_t position{6};
5874 static constexpr char const * const name{"abiVersion"};
5875 static constexpr char const * const typestr{"unsigned"};
5876 static constexpr bool traverse{false};
5877 static constexpr auto mbr_ptr{&SgAsmGenericFormat::p_abiVersion};
5878 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5879 using bind = Desc<SgAsmGenericFormat, unsigned SgAsmGenericFormat::*, &SgAsmGenericFormat::p_abiVersion>;
5880};
5881template <> struct describe_field_t<SgAsmGenericFormat,size_t,&SgAsmGenericFormat::p_wordSize> {
5882 using parent = SgAsmGenericFormat;
5883 using field_type = size_t;
5884 static constexpr size_t position{7};
5885 static constexpr char const * const name{"wordSize"};
5886 static constexpr char const * const typestr{"size_t"};
5887 static constexpr bool traverse{false};
5888 static constexpr auto mbr_ptr{&SgAsmGenericFormat::p_wordSize};
5889 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5890 using bind = Desc<SgAsmGenericFormat, size_t SgAsmGenericFormat::*, &SgAsmGenericFormat::p_wordSize>;
5891};
5901template <> struct node_from_variant_t<198> { using type = SgAsmGenericFormat; };
5902
5903// Class: AsmGenericHeader
5904template <> struct describe_field_t<SgAsmGenericHeader,SgAsmGenericFormat*,&SgAsmGenericHeader::p_executableFormat> {
5905 using parent = SgAsmGenericHeader;
5907 static constexpr size_t position{0};
5908 static constexpr char const * const name{"executableFormat"};
5909 static constexpr char const * const typestr{"SgAsmGenericFormat*"};
5910 static constexpr bool traverse{true};
5911 static constexpr auto mbr_ptr{&SgAsmGenericHeader::p_executableFormat};
5912 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5913 using bind = Desc<SgAsmGenericHeader, SgAsmGenericFormat* SgAsmGenericHeader::*, &SgAsmGenericHeader::p_executableFormat>;
5914};
5915template <> struct describe_field_t<SgAsmGenericHeader,SgCharList,&SgAsmGenericHeader::p_magic> {
5916 using parent = SgAsmGenericHeader;
5917 using field_type = SgCharList;
5918 static constexpr size_t position{1};
5919 static constexpr char const * const name{"magic"};
5920 static constexpr char const * const typestr{"SgCharList"};
5921 static constexpr bool traverse{false};
5922 static constexpr auto mbr_ptr{&SgAsmGenericHeader::p_magic};
5923 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5924 using bind = Desc<SgAsmGenericHeader, SgCharList SgAsmGenericHeader::*, &SgAsmGenericHeader::p_magic>;
5925};
5926template <> struct describe_field_t<SgAsmGenericHeader,SgAsmGenericFormat::InsSetArchitecture,&SgAsmGenericHeader::p_isa> {
5927 using parent = SgAsmGenericHeader;
5929 static constexpr size_t position{2};
5930 static constexpr char const * const name{"isa"};
5931 static constexpr char const * const typestr{"SgAsmGenericFormat::InsSetArchitecture"};
5932 static constexpr bool traverse{false};
5933 static constexpr auto mbr_ptr{&SgAsmGenericHeader::p_isa};
5934 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5935 using bind = Desc<SgAsmGenericHeader, SgAsmGenericFormat::InsSetArchitecture SgAsmGenericHeader::*, &SgAsmGenericHeader::p_isa>;
5936};
5937template <> struct describe_field_t<SgAsmGenericHeader,Rose::BinaryAnalysis::Address,&SgAsmGenericHeader::p_baseVa> {
5938 using parent = SgAsmGenericHeader;
5939 using field_type = Rose::BinaryAnalysis::Address;
5940 static constexpr size_t position{3};
5941 static constexpr char const * const name{"baseVa"};
5942 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
5943 static constexpr bool traverse{false};
5944 static constexpr auto mbr_ptr{&SgAsmGenericHeader::p_baseVa};
5945 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5946 using bind = Desc<SgAsmGenericHeader, Rose::BinaryAnalysis::Address SgAsmGenericHeader::*, &SgAsmGenericHeader::p_baseVa>;
5947};
5948template <> struct describe_field_t<SgAsmGenericHeader,SgRVAList,&SgAsmGenericHeader::p_entryRvas> {
5949 using parent = SgAsmGenericHeader;
5950 using field_type = SgRVAList;
5951 static constexpr size_t position{4};
5952 static constexpr char const * const name{"entryRvas"};
5953 static constexpr char const * const typestr{"SgRVAList"};
5954 static constexpr bool traverse{false};
5955 static constexpr auto mbr_ptr{&SgAsmGenericHeader::p_entryRvas};
5956 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5957 using bind = Desc<SgAsmGenericHeader, SgRVAList SgAsmGenericHeader::*, &SgAsmGenericHeader::p_entryRvas>;
5958};
5959template <> struct describe_field_t<SgAsmGenericHeader,SgAsmGenericDLLList*,&SgAsmGenericHeader::p_dlls> {
5960 using parent = SgAsmGenericHeader;
5962 static constexpr size_t position{5};
5963 static constexpr char const * const name{"dlls"};
5964 static constexpr char const * const typestr{"SgAsmGenericDLLList*"};
5965 static constexpr bool traverse{true};
5966 static constexpr auto mbr_ptr{&SgAsmGenericHeader::p_dlls};
5967 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5968 using bind = Desc<SgAsmGenericHeader, SgAsmGenericDLLList* SgAsmGenericHeader::*, &SgAsmGenericHeader::p_dlls>;
5969};
5970template <> struct describe_field_t<SgAsmGenericHeader,SgAsmGenericSectionList*,&SgAsmGenericHeader::p_sections> {
5971 using parent = SgAsmGenericHeader;
5973 static constexpr size_t position{6};
5974 static constexpr char const * const name{"sections"};
5975 static constexpr char const * const typestr{"SgAsmGenericSectionList*"};
5976 static constexpr bool traverse{true};
5977 static constexpr auto mbr_ptr{&SgAsmGenericHeader::p_sections};
5978 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
5979 using bind = Desc<SgAsmGenericHeader, SgAsmGenericSectionList* SgAsmGenericHeader::*, &SgAsmGenericHeader::p_sections>;
5980};
5990template <> struct node_from_variant_t<199> { using type = SgAsmGenericHeader; };
5991
5992// Class: AsmGenericHeaderList
5993template <> struct describe_field_t<SgAsmGenericHeaderList,SgAsmGenericHeaderPtrList,&SgAsmGenericHeaderList::p_headers> {
5995 using field_type = SgAsmGenericHeaderPtrList;
5996 static constexpr size_t position{0};
5997 static constexpr char const * const name{"headers"};
5998 static constexpr char const * const typestr{"SgAsmGenericHeaderPtrList"};
5999 static constexpr bool traverse{true};
6000 static constexpr auto mbr_ptr{&SgAsmGenericHeaderList::p_headers};
6001 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6002 using bind = Desc<SgAsmGenericHeaderList, SgAsmGenericHeaderPtrList SgAsmGenericHeaderList::*, &SgAsmGenericHeaderList::p_headers>;
6003};
6007 static constexpr char const * const name{"AsmGenericHeaderList"};
6008 static constexpr unsigned long variant{200};
6009 static constexpr bool concrete{true};
6010 using subclasses_t = mp::List<>;
6012};
6013template <> struct node_from_variant_t<200> { using type = SgAsmGenericHeaderList; };
6014
6015// Class: AsmGenericSection
6016template <> struct describe_field_t<SgAsmGenericSection,SgAsmGenericFile*,&SgAsmGenericSection::p_file> {
6019 static constexpr size_t position{0};
6020 static constexpr char const * const name{"file"};
6021 static constexpr char const * const typestr{"SgAsmGenericFile*"};
6022 static constexpr bool traverse{false};
6023 static constexpr auto mbr_ptr{&SgAsmGenericSection::p_file};
6024 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6025 using bind = Desc<SgAsmGenericSection, SgAsmGenericFile* SgAsmGenericSection::*, &SgAsmGenericSection::p_file>;
6026};
6027template <> struct describe_field_t<SgAsmGenericSection,SgAsmGenericHeader*,&SgAsmGenericSection::p_header> {
6030 static constexpr size_t position{1};
6031 static constexpr char const * const name{"header"};
6032 static constexpr char const * const typestr{"SgAsmGenericHeader*"};
6033 static constexpr bool traverse{false};
6034 static constexpr auto mbr_ptr{&SgAsmGenericSection::p_header};
6035 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6036 using bind = Desc<SgAsmGenericSection, SgAsmGenericHeader* SgAsmGenericSection::*, &SgAsmGenericSection::p_header>;
6037};
6038template <> struct describe_field_t<SgAsmGenericSection,Rose::BinaryAnalysis::Address,&SgAsmGenericSection::p_size> {
6040 using field_type = Rose::BinaryAnalysis::Address;
6041 static constexpr size_t position{2};
6042 static constexpr char const * const name{"size"};
6043 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
6044 static constexpr bool traverse{false};
6045 static constexpr auto mbr_ptr{&SgAsmGenericSection::p_size};
6046 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6047 using bind = Desc<SgAsmGenericSection, Rose::BinaryAnalysis::Address SgAsmGenericSection::*, &SgAsmGenericSection::p_size>;
6048};
6049template <> struct describe_field_t<SgAsmGenericSection,Rose::BinaryAnalysis::Address,&SgAsmGenericSection::p_offset> {
6051 using field_type = Rose::BinaryAnalysis::Address;
6052 static constexpr size_t position{3};
6053 static constexpr char const * const name{"offset"};
6054 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
6055 static constexpr bool traverse{false};
6056 static constexpr auto mbr_ptr{&SgAsmGenericSection::p_offset};
6057 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6058 using bind = Desc<SgAsmGenericSection, Rose::BinaryAnalysis::Address SgAsmGenericSection::*, &SgAsmGenericSection::p_offset>;
6059};
6060template <> struct describe_field_t<SgAsmGenericSection,Rose::BinaryAnalysis::Address,&SgAsmGenericSection::p_fileAlignment> {
6062 using field_type = Rose::BinaryAnalysis::Address;
6063 static constexpr size_t position{4};
6064 static constexpr char const * const name{"fileAlignment"};
6065 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
6066 static constexpr bool traverse{false};
6067 static constexpr auto mbr_ptr{&SgAsmGenericSection::p_fileAlignment};
6068 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6069 using bind = Desc<SgAsmGenericSection, Rose::BinaryAnalysis::Address SgAsmGenericSection::*, &SgAsmGenericSection::p_fileAlignment>;
6070};
6071template <> struct describe_field_t<SgAsmGenericSection,SgFileContentList,&SgAsmGenericSection::p_data> {
6074 static constexpr size_t position{5};
6075 static constexpr char const * const name{"data"};
6076 static constexpr char const * const typestr{"SgFileContentList"};
6077 static constexpr bool traverse{false};
6078 static constexpr auto mbr_ptr{&SgAsmGenericSection::p_data};
6079 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6080 using bind = Desc<SgAsmGenericSection, SgFileContentList SgAsmGenericSection::*, &SgAsmGenericSection::p_data>;
6081};
6082template <> struct describe_field_t<SgAsmGenericSection,SgAsmGenericSection::SectionPurpose,&SgAsmGenericSection::p_purpose> {
6085 static constexpr size_t position{6};
6086 static constexpr char const * const name{"purpose"};
6087 static constexpr char const * const typestr{"SgAsmGenericSection::SectionPurpose"};
6088 static constexpr bool traverse{false};
6089 static constexpr auto mbr_ptr{&SgAsmGenericSection::p_purpose};
6090 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6091 using bind = Desc<SgAsmGenericSection, SgAsmGenericSection::SectionPurpose SgAsmGenericSection::*, &SgAsmGenericSection::p_purpose>;
6092};
6093template <> struct describe_field_t<SgAsmGenericSection,bool,&SgAsmGenericSection::p_synthesized> {
6095 using field_type = bool;
6096 static constexpr size_t position{7};
6097 static constexpr char const * const name{"synthesized"};
6098 static constexpr char const * const typestr{"bool"};
6099 static constexpr bool traverse{false};
6100 static constexpr auto mbr_ptr{&SgAsmGenericSection::p_synthesized};
6101 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6102 using bind = Desc<SgAsmGenericSection, bool SgAsmGenericSection::*, &SgAsmGenericSection::p_synthesized>;
6103};
6104template <> struct describe_field_t<SgAsmGenericSection,int,&SgAsmGenericSection::p_id> {
6106 using field_type = int;
6107 static constexpr size_t position{8};
6108 static constexpr char const * const name{"id"};
6109 static constexpr char const * const typestr{"int"};
6110 static constexpr bool traverse{false};
6111 static constexpr auto mbr_ptr{&SgAsmGenericSection::p_id};
6112 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6113 using bind = Desc<SgAsmGenericSection, int SgAsmGenericSection::*, &SgAsmGenericSection::p_id>;
6114};
6115template <> struct describe_field_t<SgAsmGenericSection,SgAsmGenericString*,&SgAsmGenericSection::p_name> {
6118 static constexpr size_t position{9};
6119 static constexpr char const * const name{"name"};
6120 static constexpr char const * const typestr{"SgAsmGenericString*"};
6121 static constexpr bool traverse{false};
6122 static constexpr auto mbr_ptr{&SgAsmGenericSection::p_name};
6123 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6124 using bind = Desc<SgAsmGenericSection, SgAsmGenericString* SgAsmGenericSection::*, &SgAsmGenericSection::p_name>;
6125};
6126template <> struct describe_field_t<SgAsmGenericSection,std::string,&SgAsmGenericSection::p_shortName> {
6128 using field_type = std::string;
6129 static constexpr size_t position{10};
6130 static constexpr char const * const name{"shortName"};
6131 static constexpr char const * const typestr{"std::string"};
6132 static constexpr bool traverse{false};
6133 static constexpr auto mbr_ptr{&SgAsmGenericSection::p_shortName};
6134 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6135 using bind = Desc<SgAsmGenericSection, std::string SgAsmGenericSection::*, &SgAsmGenericSection::p_shortName>;
6136};
6137template <> struct describe_field_t<SgAsmGenericSection,Rose::BinaryAnalysis::Address,&SgAsmGenericSection::p_mappedPreferredRva> {
6139 using field_type = Rose::BinaryAnalysis::Address;
6140 static constexpr size_t position{11};
6141 static constexpr char const * const name{"mappedPreferredRva"};
6142 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
6143 static constexpr bool traverse{false};
6144 static constexpr auto mbr_ptr{&SgAsmGenericSection::p_mappedPreferredRva};
6145 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6146 using bind = Desc<SgAsmGenericSection, Rose::BinaryAnalysis::Address SgAsmGenericSection::*, &SgAsmGenericSection::p_mappedPreferredRva>;
6147};
6148template <> struct describe_field_t<SgAsmGenericSection,Rose::BinaryAnalysis::Address,&SgAsmGenericSection::p_mappedSize> {
6150 using field_type = Rose::BinaryAnalysis::Address;
6151 static constexpr size_t position{12};
6152 static constexpr char const * const name{"mappedSize"};
6153 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
6154 static constexpr bool traverse{false};
6155 static constexpr auto mbr_ptr{&SgAsmGenericSection::p_mappedSize};
6156 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6157 using bind = Desc<SgAsmGenericSection, Rose::BinaryAnalysis::Address SgAsmGenericSection::*, &SgAsmGenericSection::p_mappedSize>;
6158};
6159template <> struct describe_field_t<SgAsmGenericSection,Rose::BinaryAnalysis::Address,&SgAsmGenericSection::p_mappedAlignment> {
6161 using field_type = Rose::BinaryAnalysis::Address;
6162 static constexpr size_t position{13};
6163 static constexpr char const * const name{"mappedAlignment"};
6164 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
6165 static constexpr bool traverse{false};
6166 static constexpr auto mbr_ptr{&SgAsmGenericSection::p_mappedAlignment};
6167 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6168 using bind = Desc<SgAsmGenericSection, Rose::BinaryAnalysis::Address SgAsmGenericSection::*, &SgAsmGenericSection::p_mappedAlignment>;
6169};
6170template <> struct describe_field_t<SgAsmGenericSection,bool,&SgAsmGenericSection::p_mappedReadPermission> {
6172 using field_type = bool;
6173 static constexpr size_t position{14};
6174 static constexpr char const * const name{"mappedReadPermission"};
6175 static constexpr char const * const typestr{"bool"};
6176 static constexpr bool traverse{false};
6177 static constexpr auto mbr_ptr{&SgAsmGenericSection::p_mappedReadPermission};
6178 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6179 using bind = Desc<SgAsmGenericSection, bool SgAsmGenericSection::*, &SgAsmGenericSection::p_mappedReadPermission>;
6180};
6181template <> struct describe_field_t<SgAsmGenericSection,bool,&SgAsmGenericSection::p_mappedWritePermission> {
6183 using field_type = bool;
6184 static constexpr size_t position{15};
6185 static constexpr char const * const name{"mappedWritePermission"};
6186 static constexpr char const * const typestr{"bool"};
6187 static constexpr bool traverse{false};
6188 static constexpr auto mbr_ptr{&SgAsmGenericSection::p_mappedWritePermission};
6189 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6190 using bind = Desc<SgAsmGenericSection, bool SgAsmGenericSection::*, &SgAsmGenericSection::p_mappedWritePermission>;
6191};
6192template <> struct describe_field_t<SgAsmGenericSection,bool,&SgAsmGenericSection::p_mappedExecutePermission> {
6194 using field_type = bool;
6195 static constexpr size_t position{16};
6196 static constexpr char const * const name{"mappedExecutePermission"};
6197 static constexpr char const * const typestr{"bool"};
6198 static constexpr bool traverse{false};
6199 static constexpr auto mbr_ptr{&SgAsmGenericSection::p_mappedExecutePermission};
6200 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6201 using bind = Desc<SgAsmGenericSection, bool SgAsmGenericSection::*, &SgAsmGenericSection::p_mappedExecutePermission>;
6202};
6203template <> struct describe_field_t<SgAsmGenericSection,bool,&SgAsmGenericSection::p_containsCode> {
6205 using field_type = bool;
6206 static constexpr size_t position{17};
6207 static constexpr char const * const name{"containsCode"};
6208 static constexpr char const * const typestr{"bool"};
6209 static constexpr bool traverse{false};
6210 static constexpr auto mbr_ptr{&SgAsmGenericSection::p_containsCode};
6211 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6212 using bind = Desc<SgAsmGenericSection, bool SgAsmGenericSection::*, &SgAsmGenericSection::p_containsCode>;
6213};
6214template <> struct describe_field_t<SgAsmGenericSection,Rose::BinaryAnalysis::Address,&SgAsmGenericSection::p_mappedActualVa> {
6216 using field_type = Rose::BinaryAnalysis::Address;
6217 static constexpr size_t position{18};
6218 static constexpr char const * const name{"mappedActualVa"};
6219 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
6220 static constexpr bool traverse{false};
6221 static constexpr auto mbr_ptr{&SgAsmGenericSection::p_mappedActualVa};
6222 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6223 using bind = Desc<SgAsmGenericSection, Rose::BinaryAnalysis::Address SgAsmGenericSection::*, &SgAsmGenericSection::p_mappedActualVa>;
6224};
6226 using node = SgAsmGenericSection;
6228 static constexpr char const * const name{"AsmGenericSection"};
6229 static constexpr unsigned long variant{201};
6230 static constexpr bool concrete{true};
6232 using fields_t = mp::List<describe_field_t<SgAsmGenericSection,SgAsmGenericFile*,&SgAsmGenericSection::p_file>, describe_field_t<SgAsmGenericSection,SgAsmGenericHeader*,&SgAsmGenericSection::p_header>, describe_field_t<SgAsmGenericSection,Rose::BinaryAnalysis::Address,&SgAsmGenericSection::p_size>, describe_field_t<SgAsmGenericSection,Rose::BinaryAnalysis::Address,&SgAsmGenericSection::p_offset>, describe_field_t<SgAsmGenericSection,Rose::BinaryAnalysis::Address,&SgAsmGenericSection::p_fileAlignment>, describe_field_t<SgAsmGenericSection,SgFileContentList,&SgAsmGenericSection::p_data>, describe_field_t<SgAsmGenericSection,SgAsmGenericSection::SectionPurpose,&SgAsmGenericSection::p_purpose>, describe_field_t<SgAsmGenericSection,bool,&SgAsmGenericSection::p_synthesized>, describe_field_t<SgAsmGenericSection,int,&SgAsmGenericSection::p_id>, describe_field_t<SgAsmGenericSection,SgAsmGenericString*,&SgAsmGenericSection::p_name>, describe_field_t<SgAsmGenericSection,std::string,&SgAsmGenericSection::p_shortName>, describe_field_t<SgAsmGenericSection,Rose::BinaryAnalysis::Address,&SgAsmGenericSection::p_mappedPreferredRva>, describe_field_t<SgAsmGenericSection,Rose::BinaryAnalysis::Address,&SgAsmGenericSection::p_mappedSize>, describe_field_t<SgAsmGenericSection,Rose::BinaryAnalysis::Address,&SgAsmGenericSection::p_mappedAlignment>, describe_field_t<SgAsmGenericSection,bool,&SgAsmGenericSection::p_mappedReadPermission>, describe_field_t<SgAsmGenericSection,bool,&SgAsmGenericSection::p_mappedWritePermission>, describe_field_t<SgAsmGenericSection,bool,&SgAsmGenericSection::p_mappedExecutePermission>, describe_field_t<SgAsmGenericSection,bool,&SgAsmGenericSection::p_containsCode>, describe_field_t<SgAsmGenericSection,Rose::BinaryAnalysis::Address,&SgAsmGenericSection::p_mappedActualVa>>;
6233};
6234template <> struct node_from_variant_t<201> { using type = SgAsmGenericSection; };
6235
6236// Class: AsmGenericSectionList
6237template <> struct describe_field_t<SgAsmGenericSectionList,SgAsmGenericSectionPtrList,&SgAsmGenericSectionList::p_sections> {
6239 using field_type = SgAsmGenericSectionPtrList;
6240 static constexpr size_t position{0};
6241 static constexpr char const * const name{"sections"};
6242 static constexpr char const * const typestr{"SgAsmGenericSectionPtrList"};
6243 static constexpr bool traverse{true};
6244 static constexpr auto mbr_ptr{&SgAsmGenericSectionList::p_sections};
6245 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6246 using bind = Desc<SgAsmGenericSectionList, SgAsmGenericSectionPtrList SgAsmGenericSectionList::*, &SgAsmGenericSectionList::p_sections>;
6247};
6251 static constexpr char const * const name{"AsmGenericSectionList"};
6252 static constexpr unsigned long variant{202};
6253 static constexpr bool concrete{true};
6254 using subclasses_t = mp::List<>;
6256};
6257template <> struct node_from_variant_t<202> { using type = SgAsmGenericSectionList; };
6258
6259// Class: AsmGenericString
6261 using node = SgAsmGenericString;
6263 static constexpr char const * const name{"AsmGenericString"};
6264 static constexpr unsigned long variant{203};
6265 static constexpr bool concrete{false};
6267 using fields_t = mp::List<>;
6268};
6269template <> struct node_from_variant_t<203> { using type = SgAsmGenericString; };
6270
6271// Class: AsmGenericStrtab
6272template <> struct describe_field_t<SgAsmGenericStrtab,SgAsmGenericSection*,&SgAsmGenericStrtab::p_container> {
6273 using parent = SgAsmGenericStrtab;
6275 static constexpr size_t position{0};
6276 static constexpr char const * const name{"container"};
6277 static constexpr char const * const typestr{"SgAsmGenericSection*"};
6278 static constexpr bool traverse{false};
6279 static constexpr auto mbr_ptr{&SgAsmGenericStrtab::p_container};
6280 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6281 using bind = Desc<SgAsmGenericStrtab, SgAsmGenericSection* SgAsmGenericStrtab::*, &SgAsmGenericStrtab::p_container>;
6282};
6283template <> struct describe_field_t<SgAsmGenericStrtab,SgAsmGenericStrtab::referenced_t,&SgAsmGenericStrtab::p_storageList> {
6284 using parent = SgAsmGenericStrtab;
6285 using field_type = SgAsmGenericStrtab::referenced_t;
6286 static constexpr size_t position{1};
6287 static constexpr char const * const name{"storageList"};
6288 static constexpr char const * const typestr{"SgAsmGenericStrtab::referenced_t"};
6289 static constexpr bool traverse{false};
6290 static constexpr auto mbr_ptr{&SgAsmGenericStrtab::p_storageList};
6291 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6292 using bind = Desc<SgAsmGenericStrtab, SgAsmGenericStrtab::referenced_t SgAsmGenericStrtab::*, &SgAsmGenericStrtab::p_storageList>;
6293};
6294template <> struct describe_field_t<SgAsmGenericStrtab,Rose::BinaryAnalysis::AddressIntervalSet,&SgAsmGenericStrtab::p_freeList> {
6295 using parent = SgAsmGenericStrtab;
6297 static constexpr size_t position{2};
6298 static constexpr char const * const name{"freeList"};
6299 static constexpr char const * const typestr{"Rose::BinaryAnalysis::AddressIntervalSet"};
6300 static constexpr bool traverse{false};
6301 static constexpr auto mbr_ptr{&SgAsmGenericStrtab::p_freeList};
6302 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6303 using bind = Desc<SgAsmGenericStrtab, Rose::BinaryAnalysis::AddressIntervalSet SgAsmGenericStrtab::*, &SgAsmGenericStrtab::p_freeList>;
6304};
6305template <> struct describe_field_t<SgAsmGenericStrtab,SgAsmStringStorage*,&SgAsmGenericStrtab::p_dontFree> {
6306 using parent = SgAsmGenericStrtab;
6308 static constexpr size_t position{3};
6309 static constexpr char const * const name{"dontFree"};
6310 static constexpr char const * const typestr{"SgAsmStringStorage*"};
6311 static constexpr bool traverse{false};
6312 static constexpr auto mbr_ptr{&SgAsmGenericStrtab::p_dontFree};
6313 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6314 using bind = Desc<SgAsmGenericStrtab, SgAsmStringStorage* SgAsmGenericStrtab::*, &SgAsmGenericStrtab::p_dontFree>;
6315};
6316template <> struct describe_field_t<SgAsmGenericStrtab,size_t,&SgAsmGenericStrtab::p_numberFreed> {
6317 using parent = SgAsmGenericStrtab;
6318 using field_type = size_t;
6319 static constexpr size_t position{4};
6320 static constexpr char const * const name{"numberFreed"};
6321 static constexpr char const * const typestr{"size_t"};
6322 static constexpr bool traverse{false};
6323 static constexpr auto mbr_ptr{&SgAsmGenericStrtab::p_numberFreed};
6324 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6325 using bind = Desc<SgAsmGenericStrtab, size_t SgAsmGenericStrtab::*, &SgAsmGenericStrtab::p_numberFreed>;
6326};
6336template <> struct node_from_variant_t<204> { using type = SgAsmGenericStrtab; };
6337
6338// Class: AsmGenericSymbol
6339template <> struct describe_field_t<SgAsmGenericSymbol,SgAsmGenericSymbol::SymbolDefState,&SgAsmGenericSymbol::p_definitionState> {
6340 using parent = SgAsmGenericSymbol;
6342 static constexpr size_t position{0};
6343 static constexpr char const * const name{"definitionState"};
6344 static constexpr char const * const typestr{"SgAsmGenericSymbol::SymbolDefState"};
6345 static constexpr bool traverse{false};
6346 static constexpr auto mbr_ptr{&SgAsmGenericSymbol::p_definitionState};
6347 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6348 using bind = Desc<SgAsmGenericSymbol, SgAsmGenericSymbol::SymbolDefState SgAsmGenericSymbol::*, &SgAsmGenericSymbol::p_definitionState>;
6349};
6350template <> struct describe_field_t<SgAsmGenericSymbol,SgAsmGenericSymbol::SymbolBinding,&SgAsmGenericSymbol::p_binding> {
6351 using parent = SgAsmGenericSymbol;
6353 static constexpr size_t position{1};
6354 static constexpr char const * const name{"binding"};
6355 static constexpr char const * const typestr{"SgAsmGenericSymbol::SymbolBinding"};
6356 static constexpr bool traverse{false};
6357 static constexpr auto mbr_ptr{&SgAsmGenericSymbol::p_binding};
6358 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6359 using bind = Desc<SgAsmGenericSymbol, SgAsmGenericSymbol::SymbolBinding SgAsmGenericSymbol::*, &SgAsmGenericSymbol::p_binding>;
6360};
6361template <> struct describe_field_t<SgAsmGenericSymbol,SgAsmGenericSymbol::SymbolType,&SgAsmGenericSymbol::p_type> {
6362 using parent = SgAsmGenericSymbol;
6364 static constexpr size_t position{2};
6365 static constexpr char const * const name{"type"};
6366 static constexpr char const * const typestr{"SgAsmGenericSymbol::SymbolType"};
6367 static constexpr bool traverse{false};
6368 static constexpr auto mbr_ptr{&SgAsmGenericSymbol::p_type};
6369 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6370 using bind = Desc<SgAsmGenericSymbol, SgAsmGenericSymbol::SymbolType SgAsmGenericSymbol::*, &SgAsmGenericSymbol::p_type>;
6371};
6372template <> struct describe_field_t<SgAsmGenericSymbol,Rose::BinaryAnalysis::Address,&SgAsmGenericSymbol::p_value> {
6373 using parent = SgAsmGenericSymbol;
6374 using field_type = Rose::BinaryAnalysis::Address;
6375 static constexpr size_t position{3};
6376 static constexpr char const * const name{"value"};
6377 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
6378 static constexpr bool traverse{false};
6379 static constexpr auto mbr_ptr{&SgAsmGenericSymbol::p_value};
6380 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6381 using bind = Desc<SgAsmGenericSymbol, Rose::BinaryAnalysis::Address SgAsmGenericSymbol::*, &SgAsmGenericSymbol::p_value>;
6382};
6383template <> struct describe_field_t<SgAsmGenericSymbol,Rose::BinaryAnalysis::Address,&SgAsmGenericSymbol::p_size> {
6384 using parent = SgAsmGenericSymbol;
6385 using field_type = Rose::BinaryAnalysis::Address;
6386 static constexpr size_t position{4};
6387 static constexpr char const * const name{"size"};
6388 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
6389 static constexpr bool traverse{false};
6390 static constexpr auto mbr_ptr{&SgAsmGenericSymbol::p_size};
6391 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6392 using bind = Desc<SgAsmGenericSymbol, Rose::BinaryAnalysis::Address SgAsmGenericSymbol::*, &SgAsmGenericSymbol::p_size>;
6393};
6394template <> struct describe_field_t<SgAsmGenericSymbol,SgAsmGenericSection*,&SgAsmGenericSymbol::p_bound> {
6395 using parent = SgAsmGenericSymbol;
6397 static constexpr size_t position{5};
6398 static constexpr char const * const name{"bound"};
6399 static constexpr char const * const typestr{"SgAsmGenericSection*"};
6400 static constexpr bool traverse{false};
6401 static constexpr auto mbr_ptr{&SgAsmGenericSymbol::p_bound};
6402 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6403 using bind = Desc<SgAsmGenericSymbol, SgAsmGenericSection* SgAsmGenericSymbol::*, &SgAsmGenericSymbol::p_bound>;
6404};
6405template <> struct describe_field_t<SgAsmGenericSymbol,SgAsmGenericString*,&SgAsmGenericSymbol::p_name> {
6406 using parent = SgAsmGenericSymbol;
6408 static constexpr size_t position{6};
6409 static constexpr char const * const name{"name"};
6410 static constexpr char const * const typestr{"SgAsmGenericString*"};
6411 static constexpr bool traverse{true};
6412 static constexpr auto mbr_ptr{&SgAsmGenericSymbol::p_name};
6413 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6414 using bind = Desc<SgAsmGenericSymbol, SgAsmGenericString* SgAsmGenericSymbol::*, &SgAsmGenericSymbol::p_name>;
6415};
6425template <> struct node_from_variant_t<205> { using type = SgAsmGenericSymbol; };
6426
6427// Class: AsmGenericSymbolList
6428template <> struct describe_field_t<SgAsmGenericSymbolList,SgAsmGenericSymbolPtrList,&SgAsmGenericSymbolList::p_symbols> {
6430 using field_type = SgAsmGenericSymbolPtrList;
6431 static constexpr size_t position{0};
6432 static constexpr char const * const name{"symbols"};
6433 static constexpr char const * const typestr{"SgAsmGenericSymbolPtrList"};
6434 static constexpr bool traverse{false};
6435 static constexpr auto mbr_ptr{&SgAsmGenericSymbolList::p_symbols};
6436 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6437 using bind = Desc<SgAsmGenericSymbolList, SgAsmGenericSymbolPtrList SgAsmGenericSymbolList::*, &SgAsmGenericSymbolList::p_symbols>;
6438};
6442 static constexpr char const * const name{"AsmGenericSymbolList"};
6443 static constexpr unsigned long variant{206};
6444 static constexpr bool concrete{true};
6445 using subclasses_t = mp::List<>;
6447};
6448template <> struct node_from_variant_t<206> { using type = SgAsmGenericSymbolList; };
6449
6450// Class: AsmIndirectRegisterExpression
6451template <> struct describe_field_t<SgAsmIndirectRegisterExpression,Rose::BinaryAnalysis::RegisterDescriptor,&SgAsmIndirectRegisterExpression::p_stride> {
6454 static constexpr size_t position{0};
6455 static constexpr char const * const name{"stride"};
6456 static constexpr char const * const typestr{"Rose::BinaryAnalysis::RegisterDescriptor"};
6457 static constexpr bool traverse{false};
6458 static constexpr auto mbr_ptr{&SgAsmIndirectRegisterExpression::p_stride};
6459 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6460 using bind = Desc<SgAsmIndirectRegisterExpression, Rose::BinaryAnalysis::RegisterDescriptor SgAsmIndirectRegisterExpression::*, &SgAsmIndirectRegisterExpression::p_stride>;
6461};
6462template <> struct describe_field_t<SgAsmIndirectRegisterExpression,Rose::BinaryAnalysis::RegisterDescriptor,&SgAsmIndirectRegisterExpression::p_offset> {
6465 static constexpr size_t position{1};
6466 static constexpr char const * const name{"offset"};
6467 static constexpr char const * const typestr{"Rose::BinaryAnalysis::RegisterDescriptor"};
6468 static constexpr bool traverse{false};
6469 static constexpr auto mbr_ptr{&SgAsmIndirectRegisterExpression::p_offset};
6470 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6471 using bind = Desc<SgAsmIndirectRegisterExpression, Rose::BinaryAnalysis::RegisterDescriptor SgAsmIndirectRegisterExpression::*, &SgAsmIndirectRegisterExpression::p_offset>;
6472};
6473template <> struct describe_field_t<SgAsmIndirectRegisterExpression,size_t,&SgAsmIndirectRegisterExpression::p_index> {
6475 using field_type = size_t;
6476 static constexpr size_t position{2};
6477 static constexpr char const * const name{"index"};
6478 static constexpr char const * const typestr{"size_t"};
6479 static constexpr bool traverse{false};
6480 static constexpr auto mbr_ptr{&SgAsmIndirectRegisterExpression::p_index};
6481 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6482 using bind = Desc<SgAsmIndirectRegisterExpression, size_t SgAsmIndirectRegisterExpression::*, &SgAsmIndirectRegisterExpression::p_index>;
6483};
6484template <> struct describe_field_t<SgAsmIndirectRegisterExpression,size_t,&SgAsmIndirectRegisterExpression::p_modulus> {
6486 using field_type = size_t;
6487 static constexpr size_t position{3};
6488 static constexpr char const * const name{"modulus"};
6489 static constexpr char const * const typestr{"size_t"};
6490 static constexpr bool traverse{false};
6491 static constexpr auto mbr_ptr{&SgAsmIndirectRegisterExpression::p_modulus};
6492 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6493 using bind = Desc<SgAsmIndirectRegisterExpression, size_t SgAsmIndirectRegisterExpression::*, &SgAsmIndirectRegisterExpression::p_modulus>;
6494};
6504template <> struct node_from_variant_t<207> { using type = SgAsmIndirectRegisterExpression; };
6505
6506// Class: AsmInstruction
6507template <> struct describe_field_t<SgAsmInstruction,uint8_t,&SgAsmInstruction::p_architectureId> {
6508 using parent = SgAsmInstruction;
6509 using field_type = uint8_t;
6510 static constexpr size_t position{0};
6511 static constexpr char const * const name{"architectureId"};
6512 static constexpr char const * const typestr{"uint8_t"};
6513 static constexpr bool traverse{false};
6514 static constexpr auto mbr_ptr{&SgAsmInstruction::p_architectureId};
6515 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6516 using bind = Desc<SgAsmInstruction, uint8_t SgAsmInstruction::*, &SgAsmInstruction::p_architectureId>;
6517};
6518template <> struct describe_field_t<SgAsmInstruction,SgUnsignedCharList,&SgAsmInstruction::p_rawBytes> {
6519 using parent = SgAsmInstruction;
6520 using field_type = SgUnsignedCharList;
6521 static constexpr size_t position{1};
6522 static constexpr char const * const name{"rawBytes"};
6523 static constexpr char const * const typestr{"SgUnsignedCharList"};
6524 static constexpr bool traverse{false};
6525 static constexpr auto mbr_ptr{&SgAsmInstruction::p_rawBytes};
6526 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6527 using bind = Desc<SgAsmInstruction, SgUnsignedCharList SgAsmInstruction::*, &SgAsmInstruction::p_rawBytes>;
6528};
6529template <> struct describe_field_t<SgAsmInstruction,SgAsmOperandList*,&SgAsmInstruction::p_operandList> {
6530 using parent = SgAsmInstruction;
6532 static constexpr size_t position{2};
6533 static constexpr char const * const name{"operandList"};
6534 static constexpr char const * const typestr{"SgAsmOperandList*"};
6535 static constexpr bool traverse{true};
6536 static constexpr auto mbr_ptr{&SgAsmInstruction::p_operandList};
6537 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6538 using bind = Desc<SgAsmInstruction, SgAsmOperandList* SgAsmInstruction::*, &SgAsmInstruction::p_operandList>;
6539};
6540template <> struct describe_field_t<SgAsmInstruction,SgAsmInstruction*,&SgAsmInstruction::p_delaySlot> {
6541 using parent = SgAsmInstruction;
6543 static constexpr size_t position{3};
6544 static constexpr char const * const name{"delaySlot"};
6545 static constexpr char const * const typestr{"SgAsmInstruction*"};
6546 static constexpr bool traverse{false};
6547 static constexpr auto mbr_ptr{&SgAsmInstruction::p_delaySlot};
6548 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6549 using bind = Desc<SgAsmInstruction, SgAsmInstruction* SgAsmInstruction::*, &SgAsmInstruction::p_delaySlot>;
6550};
6551template <> struct describe_field_t<SgAsmInstruction,SgAsmExprListExp*,&SgAsmInstruction::p_semantics> {
6552 using parent = SgAsmInstruction;
6554 static constexpr size_t position{4};
6555 static constexpr char const * const name{"semantics"};
6556 static constexpr char const * const typestr{"SgAsmExprListExp*"};
6557 static constexpr bool traverse{true};
6558 static constexpr auto mbr_ptr{&SgAsmInstruction::p_semantics};
6559 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6560 using bind = Desc<SgAsmInstruction, SgAsmExprListExp* SgAsmInstruction::*, &SgAsmInstruction::p_semantics>;
6561};
6571template <> struct node_from_variant_t<208> { using type = SgAsmInstruction; };
6572
6573// Class: AsmIntegerValueExpression
6574template <> struct describe_field_t<SgAsmIntegerValueExpression,SgNode*,&SgAsmIntegerValueExpression::p_baseNode> {
6576 using field_type = SgNode*;
6577 static constexpr size_t position{0};
6578 static constexpr char const * const name{"baseNode"};
6579 static constexpr char const * const typestr{"SgNode*"};
6580 static constexpr bool traverse{false};
6581 static constexpr auto mbr_ptr{&SgAsmIntegerValueExpression::p_baseNode};
6582 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6583 using bind = Desc<SgAsmIntegerValueExpression, SgNode* SgAsmIntegerValueExpression::*, &SgAsmIntegerValueExpression::p_baseNode>;
6584};
6588 static constexpr char const * const name{"AsmIntegerValueExpression"};
6589 static constexpr unsigned long variant{209};
6590 static constexpr bool concrete{true};
6591 using subclasses_t = mp::List<>;
6593};
6594template <> struct node_from_variant_t<209> { using type = SgAsmIntegerValueExpression; };
6595
6596// Class: AsmIntegerType
6597template <> struct describe_field_t<SgAsmIntegerType,bool,&SgAsmIntegerType::p_isSigned> {
6598 using parent = SgAsmIntegerType;
6599 using field_type = bool;
6600 static constexpr size_t position{0};
6601 static constexpr char const * const name{"isSigned"};
6602 static constexpr char const * const typestr{"bool"};
6603 static constexpr bool traverse{false};
6604 static constexpr auto mbr_ptr{&SgAsmIntegerType::p_isSigned};
6605 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6606 using bind = Desc<SgAsmIntegerType, bool SgAsmIntegerType::*, &SgAsmIntegerType::p_isSigned>;
6607};
6609 using node = SgAsmIntegerType;
6610 using base = SgAsmScalarType;
6611 static constexpr char const * const name{"AsmIntegerType"};
6612 static constexpr unsigned long variant{210};
6613 static constexpr bool concrete{true};
6614 using subclasses_t = mp::List<>;
6616};
6617template <> struct node_from_variant_t<210> { using type = SgAsmIntegerType; };
6618
6619// Class: AsmInterpretation
6620template <> struct describe_field_t<SgAsmInterpretation,SgAsmGenericHeaderList*,&SgAsmInterpretation::p_headers> {
6623 static constexpr size_t position{0};
6624 static constexpr char const * const name{"headers"};
6625 static constexpr char const * const typestr{"SgAsmGenericHeaderList*"};
6626 static constexpr bool traverse{false};
6627 static constexpr auto mbr_ptr{&SgAsmInterpretation::p_headers};
6628 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6629 using bind = Desc<SgAsmInterpretation, SgAsmGenericHeaderList* SgAsmInterpretation::*, &SgAsmInterpretation::p_headers>;
6630};
6631template <> struct describe_field_t<SgAsmInterpretation,SgAsmBlock*,&SgAsmInterpretation::p_globalBlock> {
6633 using field_type = SgAsmBlock*;
6634 static constexpr size_t position{1};
6635 static constexpr char const * const name{"globalBlock"};
6636 static constexpr char const * const typestr{"SgAsmBlock*"};
6637 static constexpr bool traverse{true};
6638 static constexpr auto mbr_ptr{&SgAsmInterpretation::p_globalBlock};
6639 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6640 using bind = Desc<SgAsmInterpretation, SgAsmBlock* SgAsmInterpretation::*, &SgAsmInterpretation::p_globalBlock>;
6641};
6642template <> struct describe_field_t<SgAsmInterpretation,bool,&SgAsmInterpretation::p_coverageComputed> {
6644 using field_type = bool;
6645 static constexpr size_t position{2};
6646 static constexpr char const * const name{"coverageComputed"};
6647 static constexpr char const * const typestr{"bool"};
6648 static constexpr bool traverse{false};
6649 static constexpr auto mbr_ptr{&SgAsmInterpretation::p_coverageComputed};
6650 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6651 using bind = Desc<SgAsmInterpretation, bool SgAsmInterpretation::*, &SgAsmInterpretation::p_coverageComputed>;
6652};
6653template <> struct describe_field_t<SgAsmInterpretation,double,&SgAsmInterpretation::p_percentageCoverage> {
6655 using field_type = double;
6656 static constexpr size_t position{3};
6657 static constexpr char const * const name{"percentageCoverage"};
6658 static constexpr char const * const typestr{"double"};
6659 static constexpr bool traverse{false};
6660 static constexpr auto mbr_ptr{&SgAsmInterpretation::p_percentageCoverage};
6661 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6662 using bind = Desc<SgAsmInterpretation, double SgAsmInterpretation::*, &SgAsmInterpretation::p_percentageCoverage>;
6663};
6673template <> struct node_from_variant_t<211> { using type = SgAsmInterpretation; };
6674
6675// Class: AsmInterpretationList
6676template <> struct describe_field_t<SgAsmInterpretationList,SgAsmInterpretationPtrList,&SgAsmInterpretationList::p_interpretations> {
6678 using field_type = SgAsmInterpretationPtrList;
6679 static constexpr size_t position{0};
6680 static constexpr char const * const name{"interpretations"};
6681 static constexpr char const * const typestr{"SgAsmInterpretationPtrList"};
6682 static constexpr bool traverse{true};
6683 static constexpr auto mbr_ptr{&SgAsmInterpretationList::p_interpretations};
6684 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6685 using bind = Desc<SgAsmInterpretationList, SgAsmInterpretationPtrList SgAsmInterpretationList::*, &SgAsmInterpretationList::p_interpretations>;
6686};
6689 using base = SgAsmNode;
6690 static constexpr char const * const name{"AsmInterpretationList"};
6691 static constexpr unsigned long variant{212};
6692 static constexpr bool concrete{true};
6693 using subclasses_t = mp::List<>;
6695};
6696template <> struct node_from_variant_t<212> { using type = SgAsmInterpretationList; };
6697
6698// Class: AsmJvmAttribute
6699template <> struct describe_field_t<SgAsmJvmAttribute,uint16_t,&SgAsmJvmAttribute::p_attribute_name_index> {
6700 using parent = SgAsmJvmAttribute;
6701 using field_type = uint16_t;
6702 static constexpr size_t position{0};
6703 static constexpr char const * const name{"attribute_name_index"};
6704 static constexpr char const * const typestr{"uint16_t"};
6705 static constexpr bool traverse{false};
6706 static constexpr auto mbr_ptr{&SgAsmJvmAttribute::p_attribute_name_index};
6707 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6708 using bind = Desc<SgAsmJvmAttribute, uint16_t SgAsmJvmAttribute::*, &SgAsmJvmAttribute::p_attribute_name_index>;
6709};
6710template <> struct describe_field_t<SgAsmJvmAttribute,uint32_t,&SgAsmJvmAttribute::p_attribute_length> {
6711 using parent = SgAsmJvmAttribute;
6712 using field_type = uint32_t;
6713 static constexpr size_t position{1};
6714 static constexpr char const * const name{"attribute_length"};
6715 static constexpr char const * const typestr{"uint32_t"};
6716 static constexpr bool traverse{false};
6717 static constexpr auto mbr_ptr{&SgAsmJvmAttribute::p_attribute_length};
6718 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6719 using bind = Desc<SgAsmJvmAttribute, uint32_t SgAsmJvmAttribute::*, &SgAsmJvmAttribute::p_attribute_length>;
6720};
6730template <> struct node_from_variant_t<213> { using type = SgAsmJvmAttribute; };
6731
6732// Class: AsmJvmCodeAttribute
6733template <> struct describe_field_t<SgAsmJvmCodeAttribute,uint16_t,&SgAsmJvmCodeAttribute::p_max_stack> {
6735 using field_type = uint16_t;
6736 static constexpr size_t position{0};
6737 static constexpr char const * const name{"max_stack"};
6738 static constexpr char const * const typestr{"uint16_t"};
6739 static constexpr bool traverse{false};
6740 static constexpr auto mbr_ptr{&SgAsmJvmCodeAttribute::p_max_stack};
6741 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6742 using bind = Desc<SgAsmJvmCodeAttribute, uint16_t SgAsmJvmCodeAttribute::*, &SgAsmJvmCodeAttribute::p_max_stack>;
6743};
6744template <> struct describe_field_t<SgAsmJvmCodeAttribute,uint16_t,&SgAsmJvmCodeAttribute::p_max_locals> {
6746 using field_type = uint16_t;
6747 static constexpr size_t position{1};
6748 static constexpr char const * const name{"max_locals"};
6749 static constexpr char const * const typestr{"uint16_t"};
6750 static constexpr bool traverse{false};
6751 static constexpr auto mbr_ptr{&SgAsmJvmCodeAttribute::p_max_locals};
6752 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6753 using bind = Desc<SgAsmJvmCodeAttribute, uint16_t SgAsmJvmCodeAttribute::*, &SgAsmJvmCodeAttribute::p_max_locals>;
6754};
6755template <> struct describe_field_t<SgAsmJvmCodeAttribute,uint32_t,&SgAsmJvmCodeAttribute::p_code_length> {
6757 using field_type = uint32_t;
6758 static constexpr size_t position{2};
6759 static constexpr char const * const name{"code_length"};
6760 static constexpr char const * const typestr{"uint32_t"};
6761 static constexpr bool traverse{false};
6762 static constexpr auto mbr_ptr{&SgAsmJvmCodeAttribute::p_code_length};
6763 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6764 using bind = Desc<SgAsmJvmCodeAttribute, uint32_t SgAsmJvmCodeAttribute::*, &SgAsmJvmCodeAttribute::p_code_length>;
6765};
6766template <> struct describe_field_t<SgAsmJvmCodeAttribute,const char*,&SgAsmJvmCodeAttribute::p_code> {
6768 using field_type = const char*;
6769 static constexpr size_t position{3};
6770 static constexpr char const * const name{"code"};
6771 static constexpr char const * const typestr{"const char*"};
6772 static constexpr bool traverse{false};
6773 static constexpr auto mbr_ptr{&SgAsmJvmCodeAttribute::p_code};
6774 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6775 using bind = Desc<SgAsmJvmCodeAttribute, const char* SgAsmJvmCodeAttribute::*, &SgAsmJvmCodeAttribute::p_code>;
6776};
6777template <> struct describe_field_t<SgAsmJvmCodeAttribute,SgAsmJvmExceptionTable*,&SgAsmJvmCodeAttribute::p_exception_table> {
6780 static constexpr size_t position{4};
6781 static constexpr char const * const name{"exception_table"};
6782 static constexpr char const * const typestr{"SgAsmJvmExceptionTable*"};
6783 static constexpr bool traverse{false};
6784 static constexpr auto mbr_ptr{&SgAsmJvmCodeAttribute::p_exception_table};
6785 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6786 using bind = Desc<SgAsmJvmCodeAttribute, SgAsmJvmExceptionTable* SgAsmJvmCodeAttribute::*, &SgAsmJvmCodeAttribute::p_exception_table>;
6787};
6788template <> struct describe_field_t<SgAsmJvmCodeAttribute,SgAsmJvmAttributeTable*,&SgAsmJvmCodeAttribute::p_attribute_table> {
6791 static constexpr size_t position{5};
6792 static constexpr char const * const name{"attribute_table"};
6793 static constexpr char const * const typestr{"SgAsmJvmAttributeTable*"};
6794 static constexpr bool traverse{false};
6795 static constexpr auto mbr_ptr{&SgAsmJvmCodeAttribute::p_attribute_table};
6796 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6797 using bind = Desc<SgAsmJvmCodeAttribute, SgAsmJvmAttributeTable* SgAsmJvmCodeAttribute::*, &SgAsmJvmCodeAttribute::p_attribute_table>;
6798};
6799template <> struct describe_field_t<SgAsmJvmCodeAttribute,Rose::BinaryAnalysis::Address,&SgAsmJvmCodeAttribute::p_code_offset> {
6801 using field_type = Rose::BinaryAnalysis::Address;
6802 static constexpr size_t position{6};
6803 static constexpr char const * const name{"code_offset"};
6804 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
6805 static constexpr bool traverse{false};
6806 static constexpr auto mbr_ptr{&SgAsmJvmCodeAttribute::p_code_offset};
6807 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6808 using bind = Desc<SgAsmJvmCodeAttribute, Rose::BinaryAnalysis::Address SgAsmJvmCodeAttribute::*, &SgAsmJvmCodeAttribute::p_code_offset>;
6809};
6819template <> struct node_from_variant_t<214> { using type = SgAsmJvmCodeAttribute; };
6820
6821// Class: AsmJvmMethod
6822template <> struct describe_field_t<SgAsmJvmMethod,uint16_t,&SgAsmJvmMethod::p_access_flags> {
6823 using parent = SgAsmJvmMethod;
6824 using field_type = uint16_t;
6825 static constexpr size_t position{0};
6826 static constexpr char const * const name{"access_flags"};
6827 static constexpr char const * const typestr{"uint16_t"};
6828 static constexpr bool traverse{false};
6829 static constexpr auto mbr_ptr{&SgAsmJvmMethod::p_access_flags};
6830 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6831 using bind = Desc<SgAsmJvmMethod, uint16_t SgAsmJvmMethod::*, &SgAsmJvmMethod::p_access_flags>;
6832};
6833template <> struct describe_field_t<SgAsmJvmMethod,uint16_t,&SgAsmJvmMethod::p_name_index> {
6834 using parent = SgAsmJvmMethod;
6835 using field_type = uint16_t;
6836 static constexpr size_t position{1};
6837 static constexpr char const * const name{"name_index"};
6838 static constexpr char const * const typestr{"uint16_t"};
6839 static constexpr bool traverse{false};
6840 static constexpr auto mbr_ptr{&SgAsmJvmMethod::p_name_index};
6841 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6842 using bind = Desc<SgAsmJvmMethod, uint16_t SgAsmJvmMethod::*, &SgAsmJvmMethod::p_name_index>;
6843};
6844template <> struct describe_field_t<SgAsmJvmMethod,uint16_t,&SgAsmJvmMethod::p_descriptor_index> {
6845 using parent = SgAsmJvmMethod;
6846 using field_type = uint16_t;
6847 static constexpr size_t position{2};
6848 static constexpr char const * const name{"descriptor_index"};
6849 static constexpr char const * const typestr{"uint16_t"};
6850 static constexpr bool traverse{false};
6851 static constexpr auto mbr_ptr{&SgAsmJvmMethod::p_descriptor_index};
6852 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6853 using bind = Desc<SgAsmJvmMethod, uint16_t SgAsmJvmMethod::*, &SgAsmJvmMethod::p_descriptor_index>;
6854};
6855template <> struct describe_field_t<SgAsmJvmMethod,SgAsmJvmAttributeTable*,&SgAsmJvmMethod::p_attribute_table> {
6856 using parent = SgAsmJvmMethod;
6858 static constexpr size_t position{3};
6859 static constexpr char const * const name{"attribute_table"};
6860 static constexpr char const * const typestr{"SgAsmJvmAttributeTable*"};
6861 static constexpr bool traverse{true};
6862 static constexpr auto mbr_ptr{&SgAsmJvmMethod::p_attribute_table};
6863 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6864 using bind = Desc<SgAsmJvmMethod, SgAsmJvmAttributeTable* SgAsmJvmMethod::*, &SgAsmJvmMethod::p_attribute_table>;
6865};
6866template <> struct describe_field_t<SgAsmJvmMethod,SgAsmInstructionList*,&SgAsmJvmMethod::p_instruction_list> {
6867 using parent = SgAsmJvmMethod;
6869 static constexpr size_t position{4};
6870 static constexpr char const * const name{"instruction_list"};
6871 static constexpr char const * const typestr{"SgAsmInstructionList*"};
6872 static constexpr bool traverse{false};
6873 static constexpr auto mbr_ptr{&SgAsmJvmMethod::p_instruction_list};
6874 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6875 using bind = Desc<SgAsmJvmMethod, SgAsmInstructionList* SgAsmJvmMethod::*, &SgAsmJvmMethod::p_instruction_list>;
6876};
6886template <> struct node_from_variant_t<215> { using type = SgAsmJvmMethod; };
6887
6888// Class: AsmJvmConstantPool
6889template <> struct describe_field_t<SgAsmJvmConstantPool,SgAsmJvmConstantPoolEntryPtrList,&SgAsmJvmConstantPool::p_entries> {
6891 using field_type = SgAsmJvmConstantPoolEntryPtrList;
6892 static constexpr size_t position{0};
6893 static constexpr char const * const name{"entries"};
6894 static constexpr char const * const typestr{"SgAsmJvmConstantPoolEntryPtrList"};
6895 static constexpr bool traverse{false};
6896 static constexpr auto mbr_ptr{&SgAsmJvmConstantPool::p_entries};
6897 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6898 using bind = Desc<SgAsmJvmConstantPool, SgAsmJvmConstantPoolEntryPtrList SgAsmJvmConstantPool::*, &SgAsmJvmConstantPool::p_entries>;
6899};
6901 using node = SgAsmJvmConstantPool;
6902 using base = SgAsmGenericSection;
6903 static constexpr char const * const name{"AsmJvmConstantPool"};
6904 static constexpr unsigned long variant{216};
6905 static constexpr bool concrete{true};
6906 using subclasses_t = mp::List<>;
6908};
6909template <> struct node_from_variant_t<216> { using type = SgAsmJvmConstantPool; };
6910
6911// Class: AsmJvmConstantPoolEntry
6912template <> struct describe_field_t<SgAsmJvmConstantPoolEntry,SgAsmJvmConstantPoolEntry::Kind,&SgAsmJvmConstantPoolEntry::p_tag> {
6915 static constexpr size_t position{0};
6916 static constexpr char const * const name{"tag"};
6917 static constexpr char const * const typestr{"SgAsmJvmConstantPoolEntry::Kind"};
6918 static constexpr bool traverse{false};
6919 static constexpr auto mbr_ptr{&SgAsmJvmConstantPoolEntry::p_tag};
6920 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6921 using bind = Desc<SgAsmJvmConstantPoolEntry, SgAsmJvmConstantPoolEntry::Kind SgAsmJvmConstantPoolEntry::*, &SgAsmJvmConstantPoolEntry::p_tag>;
6922};
6923template <> struct describe_field_t<SgAsmJvmConstantPoolEntry,uint32_t,&SgAsmJvmConstantPoolEntry::p_bytes> {
6925 using field_type = uint32_t;
6926 static constexpr size_t position{1};
6927 static constexpr char const * const name{"bytes"};
6928 static constexpr char const * const typestr{"uint32_t"};
6929 static constexpr bool traverse{false};
6930 static constexpr auto mbr_ptr{&SgAsmJvmConstantPoolEntry::p_bytes};
6931 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6932 using bind = Desc<SgAsmJvmConstantPoolEntry, uint32_t SgAsmJvmConstantPoolEntry::*, &SgAsmJvmConstantPoolEntry::p_bytes>;
6933};
6934template <> struct describe_field_t<SgAsmJvmConstantPoolEntry,uint32_t,&SgAsmJvmConstantPoolEntry::p_hi_bytes> {
6936 using field_type = uint32_t;
6937 static constexpr size_t position{2};
6938 static constexpr char const * const name{"hi_bytes"};
6939 static constexpr char const * const typestr{"uint32_t"};
6940 static constexpr bool traverse{false};
6941 static constexpr auto mbr_ptr{&SgAsmJvmConstantPoolEntry::p_hi_bytes};
6942 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6943 using bind = Desc<SgAsmJvmConstantPoolEntry, uint32_t SgAsmJvmConstantPoolEntry::*, &SgAsmJvmConstantPoolEntry::p_hi_bytes>;
6944};
6945template <> struct describe_field_t<SgAsmJvmConstantPoolEntry,uint32_t,&SgAsmJvmConstantPoolEntry::p_low_bytes> {
6947 using field_type = uint32_t;
6948 static constexpr size_t position{3};
6949 static constexpr char const * const name{"low_bytes"};
6950 static constexpr char const * const typestr{"uint32_t"};
6951 static constexpr bool traverse{false};
6952 static constexpr auto mbr_ptr{&SgAsmJvmConstantPoolEntry::p_low_bytes};
6953 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6954 using bind = Desc<SgAsmJvmConstantPoolEntry, uint32_t SgAsmJvmConstantPoolEntry::*, &SgAsmJvmConstantPoolEntry::p_low_bytes>;
6955};
6956template <> struct describe_field_t<SgAsmJvmConstantPoolEntry,uint16_t,&SgAsmJvmConstantPoolEntry::p_bootstrap_method_attr_index> {
6958 using field_type = uint16_t;
6959 static constexpr size_t position{4};
6960 static constexpr char const * const name{"bootstrap_method_attr_index"};
6961 static constexpr char const * const typestr{"uint16_t"};
6962 static constexpr bool traverse{false};
6963 static constexpr auto mbr_ptr{&SgAsmJvmConstantPoolEntry::p_bootstrap_method_attr_index};
6964 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6965 using bind = Desc<SgAsmJvmConstantPoolEntry, uint16_t SgAsmJvmConstantPoolEntry::*, &SgAsmJvmConstantPoolEntry::p_bootstrap_method_attr_index>;
6966};
6967template <> struct describe_field_t<SgAsmJvmConstantPoolEntry,uint16_t,&SgAsmJvmConstantPoolEntry::p_class_index> {
6969 using field_type = uint16_t;
6970 static constexpr size_t position{5};
6971 static constexpr char const * const name{"class_index"};
6972 static constexpr char const * const typestr{"uint16_t"};
6973 static constexpr bool traverse{false};
6974 static constexpr auto mbr_ptr{&SgAsmJvmConstantPoolEntry::p_class_index};
6975 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6976 using bind = Desc<SgAsmJvmConstantPoolEntry, uint16_t SgAsmJvmConstantPoolEntry::*, &SgAsmJvmConstantPoolEntry::p_class_index>;
6977};
6978template <> struct describe_field_t<SgAsmJvmConstantPoolEntry,uint16_t,&SgAsmJvmConstantPoolEntry::p_descriptor_index> {
6980 using field_type = uint16_t;
6981 static constexpr size_t position{6};
6982 static constexpr char const * const name{"descriptor_index"};
6983 static constexpr char const * const typestr{"uint16_t"};
6984 static constexpr bool traverse{false};
6985 static constexpr auto mbr_ptr{&SgAsmJvmConstantPoolEntry::p_descriptor_index};
6986 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6987 using bind = Desc<SgAsmJvmConstantPoolEntry, uint16_t SgAsmJvmConstantPoolEntry::*, &SgAsmJvmConstantPoolEntry::p_descriptor_index>;
6988};
6989template <> struct describe_field_t<SgAsmJvmConstantPoolEntry,uint16_t,&SgAsmJvmConstantPoolEntry::p_name_index> {
6991 using field_type = uint16_t;
6992 static constexpr size_t position{7};
6993 static constexpr char const * const name{"name_index"};
6994 static constexpr char const * const typestr{"uint16_t"};
6995 static constexpr bool traverse{false};
6996 static constexpr auto mbr_ptr{&SgAsmJvmConstantPoolEntry::p_name_index};
6997 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
6998 using bind = Desc<SgAsmJvmConstantPoolEntry, uint16_t SgAsmJvmConstantPoolEntry::*, &SgAsmJvmConstantPoolEntry::p_name_index>;
6999};
7000template <> struct describe_field_t<SgAsmJvmConstantPoolEntry,uint16_t,&SgAsmJvmConstantPoolEntry::p_name_and_type_index> {
7002 using field_type = uint16_t;
7003 static constexpr size_t position{8};
7004 static constexpr char const * const name{"name_and_type_index"};
7005 static constexpr char const * const typestr{"uint16_t"};
7006 static constexpr bool traverse{false};
7007 static constexpr auto mbr_ptr{&SgAsmJvmConstantPoolEntry::p_name_and_type_index};
7008 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7009 using bind = Desc<SgAsmJvmConstantPoolEntry, uint16_t SgAsmJvmConstantPoolEntry::*, &SgAsmJvmConstantPoolEntry::p_name_and_type_index>;
7010};
7011template <> struct describe_field_t<SgAsmJvmConstantPoolEntry,uint16_t,&SgAsmJvmConstantPoolEntry::p_reference_index> {
7013 using field_type = uint16_t;
7014 static constexpr size_t position{9};
7015 static constexpr char const * const name{"reference_index"};
7016 static constexpr char const * const typestr{"uint16_t"};
7017 static constexpr bool traverse{false};
7018 static constexpr auto mbr_ptr{&SgAsmJvmConstantPoolEntry::p_reference_index};
7019 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7020 using bind = Desc<SgAsmJvmConstantPoolEntry, uint16_t SgAsmJvmConstantPoolEntry::*, &SgAsmJvmConstantPoolEntry::p_reference_index>;
7021};
7022template <> struct describe_field_t<SgAsmJvmConstantPoolEntry,uint8_t,&SgAsmJvmConstantPoolEntry::p_reference_kind> {
7024 using field_type = uint8_t;
7025 static constexpr size_t position{10};
7026 static constexpr char const * const name{"reference_kind"};
7027 static constexpr char const * const typestr{"uint8_t"};
7028 static constexpr bool traverse{false};
7029 static constexpr auto mbr_ptr{&SgAsmJvmConstantPoolEntry::p_reference_kind};
7030 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7031 using bind = Desc<SgAsmJvmConstantPoolEntry, uint8_t SgAsmJvmConstantPoolEntry::*, &SgAsmJvmConstantPoolEntry::p_reference_kind>;
7032};
7033template <> struct describe_field_t<SgAsmJvmConstantPoolEntry,uint16_t,&SgAsmJvmConstantPoolEntry::p_string_index> {
7035 using field_type = uint16_t;
7036 static constexpr size_t position{11};
7037 static constexpr char const * const name{"string_index"};
7038 static constexpr char const * const typestr{"uint16_t"};
7039 static constexpr bool traverse{false};
7040 static constexpr auto mbr_ptr{&SgAsmJvmConstantPoolEntry::p_string_index};
7041 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7042 using bind = Desc<SgAsmJvmConstantPoolEntry, uint16_t SgAsmJvmConstantPoolEntry::*, &SgAsmJvmConstantPoolEntry::p_string_index>;
7043};
7044template <> struct describe_field_t<SgAsmJvmConstantPoolEntry,uint16_t,&SgAsmJvmConstantPoolEntry::p_length> {
7046 using field_type = uint16_t;
7047 static constexpr size_t position{12};
7048 static constexpr char const * const name{"length"};
7049 static constexpr char const * const typestr{"uint16_t"};
7050 static constexpr bool traverse{false};
7051 static constexpr auto mbr_ptr{&SgAsmJvmConstantPoolEntry::p_length};
7052 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7053 using bind = Desc<SgAsmJvmConstantPoolEntry, uint16_t SgAsmJvmConstantPoolEntry::*, &SgAsmJvmConstantPoolEntry::p_length>;
7054};
7055template <> struct describe_field_t<SgAsmJvmConstantPoolEntry,char*,&SgAsmJvmConstantPoolEntry::p_utf8_bytes> {
7057 using field_type = char*;
7058 static constexpr size_t position{13};
7059 static constexpr char const * const name{"utf8_bytes"};
7060 static constexpr char const * const typestr{"char*"};
7061 static constexpr bool traverse{false};
7062 static constexpr auto mbr_ptr{&SgAsmJvmConstantPoolEntry::p_utf8_bytes};
7063 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7064 using bind = Desc<SgAsmJvmConstantPoolEntry, char* SgAsmJvmConstantPoolEntry::*, &SgAsmJvmConstantPoolEntry::p_utf8_bytes>;
7065};
7068 using base = SgAsmJvmNode;
7069 static constexpr char const * const name{"AsmJvmConstantPoolEntry"};
7070 static constexpr unsigned long variant{217};
7071 static constexpr bool concrete{true};
7072 using subclasses_t = mp::List<>;
7074};
7075template <> struct node_from_variant_t<217> { using type = SgAsmJvmConstantPoolEntry; };
7076
7077// Class: AsmJvmConstantValue
7078template <> struct describe_field_t<SgAsmJvmConstantValue,uint16_t,&SgAsmJvmConstantValue::p_constantvalue_index> {
7080 using field_type = uint16_t;
7081 static constexpr size_t position{0};
7082 static constexpr char const * const name{"constantvalue_index"};
7083 static constexpr char const * const typestr{"uint16_t"};
7084 static constexpr bool traverse{false};
7085 static constexpr auto mbr_ptr{&SgAsmJvmConstantValue::p_constantvalue_index};
7086 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7087 using bind = Desc<SgAsmJvmConstantValue, uint16_t SgAsmJvmConstantValue::*, &SgAsmJvmConstantValue::p_constantvalue_index>;
7088};
7091 using base = SgAsmJvmAttribute;
7092 static constexpr char const * const name{"AsmJvmConstantValue"};
7093 static constexpr unsigned long variant{218};
7094 static constexpr bool concrete{true};
7095 using subclasses_t = mp::List<>;
7097};
7098template <> struct node_from_variant_t<218> { using type = SgAsmJvmConstantValue; };
7099
7100// Class: AsmJvmInstruction
7101template <> struct describe_field_t<SgAsmJvmInstruction,Rose::BinaryAnalysis::JvmInstructionKind,&SgAsmJvmInstruction::p_kind> {
7103 using field_type = Rose::BinaryAnalysis::JvmInstructionKind;
7104 static constexpr size_t position{0};
7105 static constexpr char const * const name{"kind"};
7106 static constexpr char const * const typestr{"Rose::BinaryAnalysis::JvmInstructionKind"};
7107 static constexpr bool traverse{false};
7108 static constexpr auto mbr_ptr{&SgAsmJvmInstruction::p_kind};
7109 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7110 using bind = Desc<SgAsmJvmInstruction, Rose::BinaryAnalysis::JvmInstructionKind SgAsmJvmInstruction::*, &SgAsmJvmInstruction::p_kind>;
7111};
7113 using node = SgAsmJvmInstruction;
7114 using base = SgAsmInstruction;
7115 static constexpr char const * const name{"AsmJvmInstruction"};
7116 static constexpr unsigned long variant{219};
7117 static constexpr bool concrete{true};
7118 using subclasses_t = mp::List<>;
7120};
7121template <> struct node_from_variant_t<219> { using type = SgAsmJvmInstruction; };
7122
7123// Class: AsmJvmFileHeader
7124template <> struct describe_field_t<SgAsmJvmFileHeader,uint16_t,&SgAsmJvmFileHeader::p_minor_version> {
7125 using parent = SgAsmJvmFileHeader;
7126 using field_type = uint16_t;
7127 static constexpr size_t position{0};
7128 static constexpr char const * const name{"minor_version"};
7129 static constexpr char const * const typestr{"uint16_t"};
7130 static constexpr bool traverse{false};
7131 static constexpr auto mbr_ptr{&SgAsmJvmFileHeader::p_minor_version};
7132 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7133 using bind = Desc<SgAsmJvmFileHeader, uint16_t SgAsmJvmFileHeader::*, &SgAsmJvmFileHeader::p_minor_version>;
7134};
7135template <> struct describe_field_t<SgAsmJvmFileHeader,uint16_t,&SgAsmJvmFileHeader::p_major_version> {
7136 using parent = SgAsmJvmFileHeader;
7137 using field_type = uint16_t;
7138 static constexpr size_t position{1};
7139 static constexpr char const * const name{"major_version"};
7140 static constexpr char const * const typestr{"uint16_t"};
7141 static constexpr bool traverse{false};
7142 static constexpr auto mbr_ptr{&SgAsmJvmFileHeader::p_major_version};
7143 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7144 using bind = Desc<SgAsmJvmFileHeader, uint16_t SgAsmJvmFileHeader::*, &SgAsmJvmFileHeader::p_major_version>;
7145};
7146template <> struct describe_field_t<SgAsmJvmFileHeader,uint16_t,&SgAsmJvmFileHeader::p_access_flags> {
7147 using parent = SgAsmJvmFileHeader;
7148 using field_type = uint16_t;
7149 static constexpr size_t position{2};
7150 static constexpr char const * const name{"access_flags"};
7151 static constexpr char const * const typestr{"uint16_t"};
7152 static constexpr bool traverse{false};
7153 static constexpr auto mbr_ptr{&SgAsmJvmFileHeader::p_access_flags};
7154 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7155 using bind = Desc<SgAsmJvmFileHeader, uint16_t SgAsmJvmFileHeader::*, &SgAsmJvmFileHeader::p_access_flags>;
7156};
7157template <> struct describe_field_t<SgAsmJvmFileHeader,uint16_t,&SgAsmJvmFileHeader::p_this_class> {
7158 using parent = SgAsmJvmFileHeader;
7159 using field_type = uint16_t;
7160 static constexpr size_t position{3};
7161 static constexpr char const * const name{"this_class"};
7162 static constexpr char const * const typestr{"uint16_t"};
7163 static constexpr bool traverse{false};
7164 static constexpr auto mbr_ptr{&SgAsmJvmFileHeader::p_this_class};
7165 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7166 using bind = Desc<SgAsmJvmFileHeader, uint16_t SgAsmJvmFileHeader::*, &SgAsmJvmFileHeader::p_this_class>;
7167};
7168template <> struct describe_field_t<SgAsmJvmFileHeader,uint16_t,&SgAsmJvmFileHeader::p_super_class> {
7169 using parent = SgAsmJvmFileHeader;
7170 using field_type = uint16_t;
7171 static constexpr size_t position{4};
7172 static constexpr char const * const name{"super_class"};
7173 static constexpr char const * const typestr{"uint16_t"};
7174 static constexpr bool traverse{false};
7175 static constexpr auto mbr_ptr{&SgAsmJvmFileHeader::p_super_class};
7176 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7177 using bind = Desc<SgAsmJvmFileHeader, uint16_t SgAsmJvmFileHeader::*, &SgAsmJvmFileHeader::p_super_class>;
7178};
7179template <> struct describe_field_t<SgAsmJvmFileHeader,SgAsmJvmConstantPool*,&SgAsmJvmFileHeader::p_constant_pool> {
7180 using parent = SgAsmJvmFileHeader;
7182 static constexpr size_t position{5};
7183 static constexpr char const * const name{"constant_pool"};
7184 static constexpr char const * const typestr{"SgAsmJvmConstantPool*"};
7185 static constexpr bool traverse{false};
7186 static constexpr auto mbr_ptr{&SgAsmJvmFileHeader::p_constant_pool};
7187 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7188 using bind = Desc<SgAsmJvmFileHeader, SgAsmJvmConstantPool* SgAsmJvmFileHeader::*, &SgAsmJvmFileHeader::p_constant_pool>;
7189};
7190template <> struct describe_field_t<SgAsmJvmFileHeader,std::list<uint16_t>,&SgAsmJvmFileHeader::p_interfaces> {
7191 using parent = SgAsmJvmFileHeader;
7192 using field_type = std::list<uint16_t>;
7193 static constexpr size_t position{6};
7194 static constexpr char const * const name{"interfaces"};
7195 static constexpr char const * const typestr{"std::list<uint16_t>"};
7196 static constexpr bool traverse{false};
7197 static constexpr auto mbr_ptr{&SgAsmJvmFileHeader::p_interfaces};
7198 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7199 using bind = Desc<SgAsmJvmFileHeader, std::list<uint16_t> SgAsmJvmFileHeader::*, &SgAsmJvmFileHeader::p_interfaces>;
7200};
7201template <> struct describe_field_t<SgAsmJvmFileHeader,SgAsmJvmFieldTable*,&SgAsmJvmFileHeader::p_field_table> {
7202 using parent = SgAsmJvmFileHeader;
7204 static constexpr size_t position{7};
7205 static constexpr char const * const name{"field_table"};
7206 static constexpr char const * const typestr{"SgAsmJvmFieldTable*"};
7207 static constexpr bool traverse{false};
7208 static constexpr auto mbr_ptr{&SgAsmJvmFileHeader::p_field_table};
7209 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7210 using bind = Desc<SgAsmJvmFileHeader, SgAsmJvmFieldTable* SgAsmJvmFileHeader::*, &SgAsmJvmFileHeader::p_field_table>;
7211};
7212template <> struct describe_field_t<SgAsmJvmFileHeader,SgAsmJvmMethodTable*,&SgAsmJvmFileHeader::p_method_table> {
7213 using parent = SgAsmJvmFileHeader;
7215 static constexpr size_t position{8};
7216 static constexpr char const * const name{"method_table"};
7217 static constexpr char const * const typestr{"SgAsmJvmMethodTable*"};
7218 static constexpr bool traverse{false};
7219 static constexpr auto mbr_ptr{&SgAsmJvmFileHeader::p_method_table};
7220 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7221 using bind = Desc<SgAsmJvmFileHeader, SgAsmJvmMethodTable* SgAsmJvmFileHeader::*, &SgAsmJvmFileHeader::p_method_table>;
7222};
7223template <> struct describe_field_t<SgAsmJvmFileHeader,SgAsmJvmAttributeTable*,&SgAsmJvmFileHeader::p_attribute_table> {
7224 using parent = SgAsmJvmFileHeader;
7226 static constexpr size_t position{9};
7227 static constexpr char const * const name{"attribute_table"};
7228 static constexpr char const * const typestr{"SgAsmJvmAttributeTable*"};
7229 static constexpr bool traverse{false};
7230 static constexpr auto mbr_ptr{&SgAsmJvmFileHeader::p_attribute_table};
7231 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7232 using bind = Desc<SgAsmJvmFileHeader, SgAsmJvmAttributeTable* SgAsmJvmFileHeader::*, &SgAsmJvmFileHeader::p_attribute_table>;
7233};
7243template <> struct node_from_variant_t<220> { using type = SgAsmJvmFileHeader; };
7244
7245// Class: AsmJvmNode
7255template <> struct node_from_variant_t<221> { using type = SgAsmJvmNode; };
7256
7257// Class: AsmJvmSignature
7258template <> struct describe_field_t<SgAsmJvmSignature,uint16_t,&SgAsmJvmSignature::p_signature_index> {
7259 using parent = SgAsmJvmSignature;
7260 using field_type = uint16_t;
7261 static constexpr size_t position{0};
7262 static constexpr char const * const name{"signature_index"};
7263 static constexpr char const * const typestr{"uint16_t"};
7264 static constexpr bool traverse{false};
7265 static constexpr auto mbr_ptr{&SgAsmJvmSignature::p_signature_index};
7266 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7267 using bind = Desc<SgAsmJvmSignature, uint16_t SgAsmJvmSignature::*, &SgAsmJvmSignature::p_signature_index>;
7268};
7270 using node = SgAsmJvmSignature;
7271 using base = SgAsmJvmAttribute;
7272 static constexpr char const * const name{"AsmJvmSignature"};
7273 static constexpr unsigned long variant{222};
7274 static constexpr bool concrete{true};
7275 using subclasses_t = mp::List<>;
7277};
7278template <> struct node_from_variant_t<222> { using type = SgAsmJvmSignature; };
7279
7280// Class: AsmJvmSourceFile
7281template <> struct describe_field_t<SgAsmJvmSourceFile,uint16_t,&SgAsmJvmSourceFile::p_sourcefile_index> {
7282 using parent = SgAsmJvmSourceFile;
7283 using field_type = uint16_t;
7284 static constexpr size_t position{0};
7285 static constexpr char const * const name{"sourcefile_index"};
7286 static constexpr char const * const typestr{"uint16_t"};
7287 static constexpr bool traverse{false};
7288 static constexpr auto mbr_ptr{&SgAsmJvmSourceFile::p_sourcefile_index};
7289 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7290 using bind = Desc<SgAsmJvmSourceFile, uint16_t SgAsmJvmSourceFile::*, &SgAsmJvmSourceFile::p_sourcefile_index>;
7291};
7293 using node = SgAsmJvmSourceFile;
7294 using base = SgAsmJvmAttribute;
7295 static constexpr char const * const name{"AsmJvmSourceFile"};
7296 static constexpr unsigned long variant{223};
7297 static constexpr bool concrete{true};
7298 using subclasses_t = mp::List<>;
7300};
7301template <> struct node_from_variant_t<223> { using type = SgAsmJvmSourceFile; };
7302
7303// Class: AsmLEEntryPoint
7304template <> struct describe_field_t<SgAsmLEEntryPoint,SgAsmLEEntryPointPtrList,&SgAsmLEEntryPoint::p_entries> {
7305 using parent = SgAsmLEEntryPoint;
7306 using field_type = SgAsmLEEntryPointPtrList;
7307 static constexpr size_t position{0};
7308 static constexpr char const * const name{"entries"};
7309 static constexpr char const * const typestr{"SgAsmLEEntryPointPtrList"};
7310 static constexpr bool traverse{true};
7311 static constexpr auto mbr_ptr{&SgAsmLEEntryPoint::p_entries};
7312 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7313 using bind = Desc<SgAsmLEEntryPoint, SgAsmLEEntryPointPtrList SgAsmLEEntryPoint::*, &SgAsmLEEntryPoint::p_entries>;
7314};
7315template <> struct describe_field_t<SgAsmLEEntryPoint,unsigned,&SgAsmLEEntryPoint::p_flags> {
7316 using parent = SgAsmLEEntryPoint;
7317 using field_type = unsigned;
7318 static constexpr size_t position{1};
7319 static constexpr char const * const name{"flags"};
7320 static constexpr char const * const typestr{"unsigned"};
7321 static constexpr bool traverse{false};
7322 static constexpr auto mbr_ptr{&SgAsmLEEntryPoint::p_flags};
7323 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7324 using bind = Desc<SgAsmLEEntryPoint, unsigned SgAsmLEEntryPoint::*, &SgAsmLEEntryPoint::p_flags>;
7325};
7326template <> struct describe_field_t<SgAsmLEEntryPoint,unsigned,&SgAsmLEEntryPoint::p_objnum> {
7327 using parent = SgAsmLEEntryPoint;
7328 using field_type = unsigned;
7329 static constexpr size_t position{2};
7330 static constexpr char const * const name{"objnum"};
7331 static constexpr char const * const typestr{"unsigned"};
7332 static constexpr bool traverse{false};
7333 static constexpr auto mbr_ptr{&SgAsmLEEntryPoint::p_objnum};
7334 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7335 using bind = Desc<SgAsmLEEntryPoint, unsigned SgAsmLEEntryPoint::*, &SgAsmLEEntryPoint::p_objnum>;
7336};
7337template <> struct describe_field_t<SgAsmLEEntryPoint,unsigned,&SgAsmLEEntryPoint::p_entry_type> {
7338 using parent = SgAsmLEEntryPoint;
7339 using field_type = unsigned;
7340 static constexpr size_t position{3};
7341 static constexpr char const * const name{"entry_type"};
7342 static constexpr char const * const typestr{"unsigned"};
7343 static constexpr bool traverse{false};
7344 static constexpr auto mbr_ptr{&SgAsmLEEntryPoint::p_entry_type};
7345 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7346 using bind = Desc<SgAsmLEEntryPoint, unsigned SgAsmLEEntryPoint::*, &SgAsmLEEntryPoint::p_entry_type>;
7347};
7348template <> struct describe_field_t<SgAsmLEEntryPoint,unsigned,&SgAsmLEEntryPoint::p_res1> {
7349 using parent = SgAsmLEEntryPoint;
7350 using field_type = unsigned;
7351 static constexpr size_t position{4};
7352 static constexpr char const * const name{"res1"};
7353 static constexpr char const * const typestr{"unsigned"};
7354 static constexpr bool traverse{false};
7355 static constexpr auto mbr_ptr{&SgAsmLEEntryPoint::p_res1};
7356 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7357 using bind = Desc<SgAsmLEEntryPoint, unsigned SgAsmLEEntryPoint::*, &SgAsmLEEntryPoint::p_res1>;
7358};
7359template <> struct describe_field_t<SgAsmLEEntryPoint,Rose::BinaryAnalysis::Address,&SgAsmLEEntryPoint::p_entry_offset> {
7360 using parent = SgAsmLEEntryPoint;
7361 using field_type = Rose::BinaryAnalysis::Address;
7362 static constexpr size_t position{5};
7363 static constexpr char const * const name{"entry_offset"};
7364 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
7365 static constexpr bool traverse{false};
7366 static constexpr auto mbr_ptr{&SgAsmLEEntryPoint::p_entry_offset};
7367 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7368 using bind = Desc<SgAsmLEEntryPoint, Rose::BinaryAnalysis::Address SgAsmLEEntryPoint::*, &SgAsmLEEntryPoint::p_entry_offset>;
7369};
7379template <> struct node_from_variant_t<224> { using type = SgAsmLEEntryPoint; };
7380
7381// Class: AsmLEEntryTable
7382template <> struct describe_field_t<SgAsmLEEntryTable,SgSizeTList,&SgAsmLEEntryTable::p_bundle_sizes> {
7383 using parent = SgAsmLEEntryTable;
7384 using field_type = SgSizeTList;
7385 static constexpr size_t position{0};
7386 static constexpr char const * const name{"bundle_sizes"};
7387 static constexpr char const * const typestr{"SgSizeTList"};
7388 static constexpr bool traverse{false};
7389 static constexpr auto mbr_ptr{&SgAsmLEEntryTable::p_bundle_sizes};
7390 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7391 using bind = Desc<SgAsmLEEntryTable, SgSizeTList SgAsmLEEntryTable::*, &SgAsmLEEntryTable::p_bundle_sizes>;
7392};
7393template <> struct describe_field_t<SgAsmLEEntryTable,SgAsmLEEntryPointPtrList,&SgAsmLEEntryTable::p_entries> {
7394 using parent = SgAsmLEEntryTable;
7395 using field_type = SgAsmLEEntryPointPtrList;
7396 static constexpr size_t position{1};
7397 static constexpr char const * const name{"entries"};
7398 static constexpr char const * const typestr{"SgAsmLEEntryPointPtrList"};
7399 static constexpr bool traverse{true};
7400 static constexpr auto mbr_ptr{&SgAsmLEEntryTable::p_entries};
7401 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7402 using bind = Desc<SgAsmLEEntryTable, SgAsmLEEntryPointPtrList SgAsmLEEntryTable::*, &SgAsmLEEntryTable::p_entries>;
7403};
7405 using node = SgAsmLEEntryTable;
7406 using base = SgAsmGenericSection;
7407 static constexpr char const * const name{"AsmLEEntryTable"};
7408 static constexpr unsigned long variant{225};
7409 static constexpr bool concrete{true};
7410 using subclasses_t = mp::List<>;
7412};
7413template <> struct node_from_variant_t<225> { using type = SgAsmLEEntryTable; };
7414
7415// Class: AsmLEFileHeader
7416template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_byte_order> {
7417 using parent = SgAsmLEFileHeader;
7418 using field_type = unsigned;
7419 static constexpr size_t position{0};
7420 static constexpr char const * const name{"e_byte_order"};
7421 static constexpr char const * const typestr{"unsigned"};
7422 static constexpr bool traverse{false};
7423 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_byte_order};
7424 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7425 using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_byte_order>;
7426};
7427template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_word_order> {
7428 using parent = SgAsmLEFileHeader;
7429 using field_type = unsigned;
7430 static constexpr size_t position{1};
7431 static constexpr char const * const name{"e_word_order"};
7432 static constexpr char const * const typestr{"unsigned"};
7433 static constexpr bool traverse{false};
7434 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_word_order};
7435 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7436 using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_word_order>;
7437};
7438template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_format_level> {
7439 using parent = SgAsmLEFileHeader;
7440 using field_type = unsigned;
7441 static constexpr size_t position{2};
7442 static constexpr char const * const name{"e_format_level"};
7443 static constexpr char const * const typestr{"unsigned"};
7444 static constexpr bool traverse{false};
7445 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_format_level};
7446 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7447 using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_format_level>;
7448};
7449template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_cpu_type> {
7450 using parent = SgAsmLEFileHeader;
7451 using field_type = unsigned;
7452 static constexpr size_t position{3};
7453 static constexpr char const * const name{"e_cpu_type"};
7454 static constexpr char const * const typestr{"unsigned"};
7455 static constexpr bool traverse{false};
7456 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_cpu_type};
7457 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7458 using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_cpu_type>;
7459};
7460template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_os_type> {
7461 using parent = SgAsmLEFileHeader;
7462 using field_type = unsigned;
7463 static constexpr size_t position{4};
7464 static constexpr char const * const name{"e_os_type"};
7465 static constexpr char const * const typestr{"unsigned"};
7466 static constexpr bool traverse{false};
7467 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_os_type};
7468 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7469 using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_os_type>;
7470};
7471template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_module_version> {
7472 using parent = SgAsmLEFileHeader;
7473 using field_type = unsigned;
7474 static constexpr size_t position{5};
7475 static constexpr char const * const name{"e_module_version"};
7476 static constexpr char const * const typestr{"unsigned"};
7477 static constexpr bool traverse{false};
7478 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_module_version};
7479 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7480 using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_module_version>;
7481};
7482template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_flags> {
7483 using parent = SgAsmLEFileHeader;
7484 using field_type = unsigned;
7485 static constexpr size_t position{6};
7486 static constexpr char const * const name{"e_flags"};
7487 static constexpr char const * const typestr{"unsigned"};
7488 static constexpr bool traverse{false};
7489 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_flags};
7490 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7491 using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_flags>;
7492};
7493template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_eip_section> {
7494 using parent = SgAsmLEFileHeader;
7495 using field_type = unsigned;
7496 static constexpr size_t position{7};
7497 static constexpr char const * const name{"e_eip_section"};
7498 static constexpr char const * const typestr{"unsigned"};
7499 static constexpr bool traverse{false};
7500 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_eip_section};
7501 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7502 using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_eip_section>;
7503};
7504template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_esp_section> {
7505 using parent = SgAsmLEFileHeader;
7506 using field_type = unsigned;
7507 static constexpr size_t position{8};
7508 static constexpr char const * const name{"e_esp_section"};
7509 static constexpr char const * const typestr{"unsigned"};
7510 static constexpr bool traverse{false};
7511 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_esp_section};
7512 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7513 using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_esp_section>;
7514};
7515template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_last_page_size> {
7516 using parent = SgAsmLEFileHeader;
7517 using field_type = unsigned;
7518 static constexpr size_t position{9};
7519 static constexpr char const * const name{"e_last_page_size"};
7520 static constexpr char const * const typestr{"unsigned"};
7521 static constexpr bool traverse{false};
7522 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_last_page_size};
7523 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7524 using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_last_page_size>;
7525};
7526template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_page_offset_shift> {
7527 using parent = SgAsmLEFileHeader;
7528 using field_type = unsigned;
7529 static constexpr size_t position{10};
7530 static constexpr char const * const name{"e_page_offset_shift"};
7531 static constexpr char const * const typestr{"unsigned"};
7532 static constexpr bool traverse{false};
7533 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_page_offset_shift};
7534 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7535 using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_page_offset_shift>;
7536};
7537template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_fixup_sect_cksum> {
7538 using parent = SgAsmLEFileHeader;
7539 using field_type = unsigned;
7540 static constexpr size_t position{11};
7541 static constexpr char const * const name{"e_fixup_sect_cksum"};
7542 static constexpr char const * const typestr{"unsigned"};
7543 static constexpr bool traverse{false};
7544 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_fixup_sect_cksum};
7545 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7546 using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_fixup_sect_cksum>;
7547};
7548template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_loader_sect_cksum> {
7549 using parent = SgAsmLEFileHeader;
7550 using field_type = unsigned;
7551 static constexpr size_t position{12};
7552 static constexpr char const * const name{"e_loader_sect_cksum"};
7553 static constexpr char const * const typestr{"unsigned"};
7554 static constexpr bool traverse{false};
7555 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_loader_sect_cksum};
7556 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7557 using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_loader_sect_cksum>;
7558};
7559template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_secttab_nentries> {
7560 using parent = SgAsmLEFileHeader;
7561 using field_type = unsigned;
7562 static constexpr size_t position{13};
7563 static constexpr char const * const name{"e_secttab_nentries"};
7564 static constexpr char const * const typestr{"unsigned"};
7565 static constexpr bool traverse{false};
7566 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_secttab_nentries};
7567 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7568 using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_secttab_nentries>;
7569};
7570template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_rsrctab_nentries> {
7571 using parent = SgAsmLEFileHeader;
7572 using field_type = unsigned;
7573 static constexpr size_t position{14};
7574 static constexpr char const * const name{"e_rsrctab_nentries"};
7575 static constexpr char const * const typestr{"unsigned"};
7576 static constexpr bool traverse{false};
7577 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_rsrctab_nentries};
7578 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7579 using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_rsrctab_nentries>;
7580};
7581template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_fmtdirtab_nentries> {
7582 using parent = SgAsmLEFileHeader;
7583 using field_type = unsigned;
7584 static constexpr size_t position{15};
7585 static constexpr char const * const name{"e_fmtdirtab_nentries"};
7586 static constexpr char const * const typestr{"unsigned"};
7587 static constexpr bool traverse{false};
7588 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_fmtdirtab_nentries};
7589 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7590 using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_fmtdirtab_nentries>;
7591};
7592template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_import_modtab_nentries> {
7593 using parent = SgAsmLEFileHeader;
7594 using field_type = unsigned;
7595 static constexpr size_t position{16};
7596 static constexpr char const * const name{"e_import_modtab_nentries"};
7597 static constexpr char const * const typestr{"unsigned"};
7598 static constexpr bool traverse{false};
7599 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_import_modtab_nentries};
7600 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7601 using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_import_modtab_nentries>;
7602};
7603template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_preload_npages> {
7604 using parent = SgAsmLEFileHeader;
7605 using field_type = unsigned;
7606 static constexpr size_t position{17};
7607 static constexpr char const * const name{"e_preload_npages"};
7608 static constexpr char const * const typestr{"unsigned"};
7609 static constexpr bool traverse{false};
7610 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_preload_npages};
7611 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7612 using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_preload_npages>;
7613};
7614template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_nonresnametab_size> {
7615 using parent = SgAsmLEFileHeader;
7616 using field_type = unsigned;
7617 static constexpr size_t position{18};
7618 static constexpr char const * const name{"e_nonresnametab_size"};
7619 static constexpr char const * const typestr{"unsigned"};
7620 static constexpr bool traverse{false};
7621 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_nonresnametab_size};
7622 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7623 using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_nonresnametab_size>;
7624};
7625template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_nonresnametab_cksum> {
7626 using parent = SgAsmLEFileHeader;
7627 using field_type = unsigned;
7628 static constexpr size_t position{19};
7629 static constexpr char const * const name{"e_nonresnametab_cksum"};
7630 static constexpr char const * const typestr{"unsigned"};
7631 static constexpr bool traverse{false};
7632 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_nonresnametab_cksum};
7633 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7634 using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_nonresnametab_cksum>;
7635};
7636template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_auto_ds_section> {
7637 using parent = SgAsmLEFileHeader;
7638 using field_type = unsigned;
7639 static constexpr size_t position{20};
7640 static constexpr char const * const name{"e_auto_ds_section"};
7641 static constexpr char const * const typestr{"unsigned"};
7642 static constexpr bool traverse{false};
7643 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_auto_ds_section};
7644 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7645 using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_auto_ds_section>;
7646};
7647template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_debug_info_size> {
7648 using parent = SgAsmLEFileHeader;
7649 using field_type = unsigned;
7650 static constexpr size_t position{21};
7651 static constexpr char const * const name{"e_debug_info_size"};
7652 static constexpr char const * const typestr{"unsigned"};
7653 static constexpr bool traverse{false};
7654 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_debug_info_size};
7655 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7656 using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_debug_info_size>;
7657};
7658template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_num_instance_preload> {
7659 using parent = SgAsmLEFileHeader;
7660 using field_type = unsigned;
7661 static constexpr size_t position{22};
7662 static constexpr char const * const name{"e_num_instance_preload"};
7663 static constexpr char const * const typestr{"unsigned"};
7664 static constexpr bool traverse{false};
7665 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_num_instance_preload};
7666 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7667 using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_num_instance_preload>;
7668};
7669template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_num_instance_demand> {
7670 using parent = SgAsmLEFileHeader;
7671 using field_type = unsigned;
7672 static constexpr size_t position{23};
7673 static constexpr char const * const name{"e_num_instance_demand"};
7674 static constexpr char const * const typestr{"unsigned"};
7675 static constexpr bool traverse{false};
7676 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_num_instance_demand};
7677 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7678 using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_num_instance_demand>;
7679};
7680template <> struct describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_heap_size> {
7681 using parent = SgAsmLEFileHeader;
7682 using field_type = unsigned;
7683 static constexpr size_t position{24};
7684 static constexpr char const * const name{"e_heap_size"};
7685 static constexpr char const * const typestr{"unsigned"};
7686 static constexpr bool traverse{false};
7687 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_heap_size};
7688 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7689 using bind = Desc<SgAsmLEFileHeader, unsigned SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_heap_size>;
7690};
7691template <> struct describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_npages> {
7692 using parent = SgAsmLEFileHeader;
7693 using field_type = Rose::BinaryAnalysis::Address;
7694 static constexpr size_t position{25};
7695 static constexpr char const * const name{"e_npages"};
7696 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
7697 static constexpr bool traverse{false};
7698 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_npages};
7699 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7700 using bind = Desc<SgAsmLEFileHeader, Rose::BinaryAnalysis::Address SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_npages>;
7701};
7702template <> struct describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_eip> {
7703 using parent = SgAsmLEFileHeader;
7704 using field_type = Rose::BinaryAnalysis::Address;
7705 static constexpr size_t position{26};
7706 static constexpr char const * const name{"e_eip"};
7707 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
7708 static constexpr bool traverse{false};
7709 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_eip};
7710 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7711 using bind = Desc<SgAsmLEFileHeader, Rose::BinaryAnalysis::Address SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_eip>;
7712};
7713template <> struct describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_esp> {
7714 using parent = SgAsmLEFileHeader;
7715 using field_type = Rose::BinaryAnalysis::Address;
7716 static constexpr size_t position{27};
7717 static constexpr char const * const name{"e_esp"};
7718 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
7719 static constexpr bool traverse{false};
7720 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_esp};
7721 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7722 using bind = Desc<SgAsmLEFileHeader, Rose::BinaryAnalysis::Address SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_esp>;
7723};
7724template <> struct describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_page_size> {
7725 using parent = SgAsmLEFileHeader;
7726 using field_type = Rose::BinaryAnalysis::Address;
7727 static constexpr size_t position{28};
7728 static constexpr char const * const name{"e_page_size"};
7729 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
7730 static constexpr bool traverse{false};
7731 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_page_size};
7732 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7733 using bind = Desc<SgAsmLEFileHeader, Rose::BinaryAnalysis::Address SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_page_size>;
7734};
7735template <> struct describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_fixup_sect_size> {
7736 using parent = SgAsmLEFileHeader;
7737 using field_type = Rose::BinaryAnalysis::Address;
7738 static constexpr size_t position{29};
7739 static constexpr char const * const name{"e_fixup_sect_size"};
7740 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
7741 static constexpr bool traverse{false};
7742 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_fixup_sect_size};
7743 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7744 using bind = Desc<SgAsmLEFileHeader, Rose::BinaryAnalysis::Address SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_fixup_sect_size>;
7745};
7746template <> struct describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_loader_sect_size> {
7747 using parent = SgAsmLEFileHeader;
7748 using field_type = Rose::BinaryAnalysis::Address;
7749 static constexpr size_t position{30};
7750 static constexpr char const * const name{"e_loader_sect_size"};
7751 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
7752 static constexpr bool traverse{false};
7753 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_loader_sect_size};
7754 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7755 using bind = Desc<SgAsmLEFileHeader, Rose::BinaryAnalysis::Address SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_loader_sect_size>;
7756};
7757template <> struct describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_secttab_rfo> {
7758 using parent = SgAsmLEFileHeader;
7759 using field_type = Rose::BinaryAnalysis::Address;
7760 static constexpr size_t position{31};
7761 static constexpr char const * const name{"e_secttab_rfo"};
7762 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
7763 static constexpr bool traverse{false};
7764 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_secttab_rfo};
7765 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7766 using bind = Desc<SgAsmLEFileHeader, Rose::BinaryAnalysis::Address SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_secttab_rfo>;
7767};
7768template <> struct describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_pagetab_rfo> {
7769 using parent = SgAsmLEFileHeader;
7770 using field_type = Rose::BinaryAnalysis::Address;
7771 static constexpr size_t position{32};
7772 static constexpr char const * const name{"e_pagetab_rfo"};
7773 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
7774 static constexpr bool traverse{false};
7775 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_pagetab_rfo};
7776 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7777 using bind = Desc<SgAsmLEFileHeader, Rose::BinaryAnalysis::Address SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_pagetab_rfo>;
7778};
7779template <> struct describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_iterpages_offset> {
7780 using parent = SgAsmLEFileHeader;
7781 using field_type = Rose::BinaryAnalysis::Address;
7782 static constexpr size_t position{33};
7783 static constexpr char const * const name{"e_iterpages_offset"};
7784 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
7785 static constexpr bool traverse{false};
7786 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_iterpages_offset};
7787 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7788 using bind = Desc<SgAsmLEFileHeader, Rose::BinaryAnalysis::Address SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_iterpages_offset>;
7789};
7790template <> struct describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_rsrctab_rfo> {
7791 using parent = SgAsmLEFileHeader;
7792 using field_type = Rose::BinaryAnalysis::Address;
7793 static constexpr size_t position{34};
7794 static constexpr char const * const name{"e_rsrctab_rfo"};
7795 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
7796 static constexpr bool traverse{false};
7797 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_rsrctab_rfo};
7798 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7799 using bind = Desc<SgAsmLEFileHeader, Rose::BinaryAnalysis::Address SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_rsrctab_rfo>;
7800};
7801template <> struct describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_resnametab_rfo> {
7802 using parent = SgAsmLEFileHeader;
7803 using field_type = Rose::BinaryAnalysis::Address;
7804 static constexpr size_t position{35};
7805 static constexpr char const * const name{"e_resnametab_rfo"};
7806 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
7807 static constexpr bool traverse{false};
7808 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_resnametab_rfo};
7809 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7810 using bind = Desc<SgAsmLEFileHeader, Rose::BinaryAnalysis::Address SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_resnametab_rfo>;
7811};
7812template <> struct describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_entrytab_rfo> {
7813 using parent = SgAsmLEFileHeader;
7814 using field_type = Rose::BinaryAnalysis::Address;
7815 static constexpr size_t position{36};
7816 static constexpr char const * const name{"e_entrytab_rfo"};
7817 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
7818 static constexpr bool traverse{false};
7819 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_entrytab_rfo};
7820 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7821 using bind = Desc<SgAsmLEFileHeader, Rose::BinaryAnalysis::Address SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_entrytab_rfo>;
7822};
7823template <> struct describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_fmtdirtab_rfo> {
7824 using parent = SgAsmLEFileHeader;
7825 using field_type = Rose::BinaryAnalysis::Address;
7826 static constexpr size_t position{37};
7827 static constexpr char const * const name{"e_fmtdirtab_rfo"};
7828 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
7829 static constexpr bool traverse{false};
7830 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_fmtdirtab_rfo};
7831 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7832 using bind = Desc<SgAsmLEFileHeader, Rose::BinaryAnalysis::Address SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_fmtdirtab_rfo>;
7833};
7834template <> struct describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_fixup_pagetab_rfo> {
7835 using parent = SgAsmLEFileHeader;
7836 using field_type = Rose::BinaryAnalysis::Address;
7837 static constexpr size_t position{38};
7838 static constexpr char const * const name{"e_fixup_pagetab_rfo"};
7839 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
7840 static constexpr bool traverse{false};
7841 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_fixup_pagetab_rfo};
7842 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7843 using bind = Desc<SgAsmLEFileHeader, Rose::BinaryAnalysis::Address SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_fixup_pagetab_rfo>;
7844};
7845template <> struct describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_fixup_rectab_rfo> {
7846 using parent = SgAsmLEFileHeader;
7847 using field_type = Rose::BinaryAnalysis::Address;
7848 static constexpr size_t position{39};
7849 static constexpr char const * const name{"e_fixup_rectab_rfo"};
7850 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
7851 static constexpr bool traverse{false};
7852 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_fixup_rectab_rfo};
7853 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7854 using bind = Desc<SgAsmLEFileHeader, Rose::BinaryAnalysis::Address SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_fixup_rectab_rfo>;
7855};
7856template <> struct describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_import_modtab_rfo> {
7857 using parent = SgAsmLEFileHeader;
7858 using field_type = Rose::BinaryAnalysis::Address;
7859 static constexpr size_t position{40};
7860 static constexpr char const * const name{"e_import_modtab_rfo"};
7861 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
7862 static constexpr bool traverse{false};
7863 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_import_modtab_rfo};
7864 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7865 using bind = Desc<SgAsmLEFileHeader, Rose::BinaryAnalysis::Address SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_import_modtab_rfo>;
7866};
7867template <> struct describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_import_proctab_rfo> {
7868 using parent = SgAsmLEFileHeader;
7869 using field_type = Rose::BinaryAnalysis::Address;
7870 static constexpr size_t position{41};
7871 static constexpr char const * const name{"e_import_proctab_rfo"};
7872 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
7873 static constexpr bool traverse{false};
7874 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_import_proctab_rfo};
7875 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7876 using bind = Desc<SgAsmLEFileHeader, Rose::BinaryAnalysis::Address SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_import_proctab_rfo>;
7877};
7878template <> struct describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_ppcksumtab_rfo> {
7879 using parent = SgAsmLEFileHeader;
7880 using field_type = Rose::BinaryAnalysis::Address;
7881 static constexpr size_t position{42};
7882 static constexpr char const * const name{"e_ppcksumtab_rfo"};
7883 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
7884 static constexpr bool traverse{false};
7885 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_ppcksumtab_rfo};
7886 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7887 using bind = Desc<SgAsmLEFileHeader, Rose::BinaryAnalysis::Address SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_ppcksumtab_rfo>;
7888};
7889template <> struct describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_data_pages_offset> {
7890 using parent = SgAsmLEFileHeader;
7891 using field_type = Rose::BinaryAnalysis::Address;
7892 static constexpr size_t position{43};
7893 static constexpr char const * const name{"e_data_pages_offset"};
7894 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
7895 static constexpr bool traverse{false};
7896 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_data_pages_offset};
7897 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7898 using bind = Desc<SgAsmLEFileHeader, Rose::BinaryAnalysis::Address SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_data_pages_offset>;
7899};
7900template <> struct describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_nonresnametab_offset> {
7901 using parent = SgAsmLEFileHeader;
7902 using field_type = Rose::BinaryAnalysis::Address;
7903 static constexpr size_t position{44};
7904 static constexpr char const * const name{"e_nonresnametab_offset"};
7905 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
7906 static constexpr bool traverse{false};
7907 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_nonresnametab_offset};
7908 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7909 using bind = Desc<SgAsmLEFileHeader, Rose::BinaryAnalysis::Address SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_nonresnametab_offset>;
7910};
7911template <> struct describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_debug_info_rfo> {
7912 using parent = SgAsmLEFileHeader;
7913 using field_type = Rose::BinaryAnalysis::Address;
7914 static constexpr size_t position{45};
7915 static constexpr char const * const name{"e_debug_info_rfo"};
7916 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
7917 static constexpr bool traverse{false};
7918 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_e_debug_info_rfo};
7919 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7920 using bind = Desc<SgAsmLEFileHeader, Rose::BinaryAnalysis::Address SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_e_debug_info_rfo>;
7921};
7922template <> struct describe_field_t<SgAsmLEFileHeader,SgAsmDOSExtendedHeader*,&SgAsmLEFileHeader::p_dos2Header> {
7923 using parent = SgAsmLEFileHeader;
7925 static constexpr size_t position{46};
7926 static constexpr char const * const name{"dos2Header"};
7927 static constexpr char const * const typestr{"SgAsmDOSExtendedHeader*"};
7928 static constexpr bool traverse{true};
7929 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_dos2Header};
7930 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7931 using bind = Desc<SgAsmLEFileHeader, SgAsmDOSExtendedHeader* SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_dos2Header>;
7932};
7933template <> struct describe_field_t<SgAsmLEFileHeader,SgAsmLESectionTable*,&SgAsmLEFileHeader::p_sectionTable> {
7934 using parent = SgAsmLEFileHeader;
7936 static constexpr size_t position{47};
7937 static constexpr char const * const name{"sectionTable"};
7938 static constexpr char const * const typestr{"SgAsmLESectionTable*"};
7939 static constexpr bool traverse{false};
7940 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_sectionTable};
7941 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7942 using bind = Desc<SgAsmLEFileHeader, SgAsmLESectionTable* SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_sectionTable>;
7943};
7944template <> struct describe_field_t<SgAsmLEFileHeader,SgAsmLEPageTable*,&SgAsmLEFileHeader::p_pageTable> {
7945 using parent = SgAsmLEFileHeader;
7947 static constexpr size_t position{48};
7948 static constexpr char const * const name{"pageTable"};
7949 static constexpr char const * const typestr{"SgAsmLEPageTable*"};
7950 static constexpr bool traverse{true};
7951 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_pageTable};
7952 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7953 using bind = Desc<SgAsmLEFileHeader, SgAsmLEPageTable* SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_pageTable>;
7954};
7955template <> struct describe_field_t<SgAsmLEFileHeader,SgAsmLENameTable*,&SgAsmLEFileHeader::p_residentNameTable> {
7956 using parent = SgAsmLEFileHeader;
7958 static constexpr size_t position{49};
7959 static constexpr char const * const name{"residentNameTable"};
7960 static constexpr char const * const typestr{"SgAsmLENameTable*"};
7961 static constexpr bool traverse{true};
7962 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_residentNameTable};
7963 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7964 using bind = Desc<SgAsmLEFileHeader, SgAsmLENameTable* SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_residentNameTable>;
7965};
7966template <> struct describe_field_t<SgAsmLEFileHeader,SgAsmLENameTable*,&SgAsmLEFileHeader::p_nonresidentNameTable> {
7967 using parent = SgAsmLEFileHeader;
7969 static constexpr size_t position{50};
7970 static constexpr char const * const name{"nonresidentNameTable"};
7971 static constexpr char const * const typestr{"SgAsmLENameTable*"};
7972 static constexpr bool traverse{true};
7973 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_nonresidentNameTable};
7974 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7975 using bind = Desc<SgAsmLEFileHeader, SgAsmLENameTable* SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_nonresidentNameTable>;
7976};
7977template <> struct describe_field_t<SgAsmLEFileHeader,SgAsmLEEntryTable*,&SgAsmLEFileHeader::p_entryTable> {
7978 using parent = SgAsmLEFileHeader;
7980 static constexpr size_t position{51};
7981 static constexpr char const * const name{"entryTable"};
7982 static constexpr char const * const typestr{"SgAsmLEEntryTable*"};
7983 static constexpr bool traverse{true};
7984 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_entryTable};
7985 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7986 using bind = Desc<SgAsmLEFileHeader, SgAsmLEEntryTable* SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_entryTable>;
7987};
7988template <> struct describe_field_t<SgAsmLEFileHeader,SgAsmLERelocTable*,&SgAsmLEFileHeader::p_relocationTable> {
7989 using parent = SgAsmLEFileHeader;
7991 static constexpr size_t position{52};
7992 static constexpr char const * const name{"relocationTable"};
7993 static constexpr char const * const typestr{"SgAsmLERelocTable*"};
7994 static constexpr bool traverse{true};
7995 static constexpr auto mbr_ptr{&SgAsmLEFileHeader::p_relocationTable};
7996 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
7997 using bind = Desc<SgAsmLEFileHeader, SgAsmLERelocTable* SgAsmLEFileHeader::*, &SgAsmLEFileHeader::p_relocationTable>;
7998};
8000 using node = SgAsmLEFileHeader;
8001 using base = SgAsmGenericHeader;
8002 static constexpr char const * const name{"AsmLEFileHeader"};
8003 static constexpr unsigned long variant{226};
8004 static constexpr bool concrete{true};
8005 using subclasses_t = mp::List<>;
8006 using fields_t = mp::List<describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_byte_order>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_word_order>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_format_level>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_cpu_type>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_os_type>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_module_version>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_flags>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_eip_section>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_esp_section>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_last_page_size>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_page_offset_shift>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_fixup_sect_cksum>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_loader_sect_cksum>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_secttab_nentries>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_rsrctab_nentries>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_fmtdirtab_nentries>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_import_modtab_nentries>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_preload_npages>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_nonresnametab_size>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_nonresnametab_cksum>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_auto_ds_section>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_debug_info_size>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_num_instance_preload>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_num_instance_demand>, describe_field_t<SgAsmLEFileHeader,unsigned,&SgAsmLEFileHeader::p_e_heap_size>, describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_npages>, describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_eip>, describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_esp>, describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_page_size>, describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_fixup_sect_size>, describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_loader_sect_size>, describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_secttab_rfo>, describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_pagetab_rfo>, describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_iterpages_offset>, describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_rsrctab_rfo>, describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_resnametab_rfo>, describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_entrytab_rfo>, describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_fmtdirtab_rfo>, describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_fixup_pagetab_rfo>, describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_fixup_rectab_rfo>, describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_import_modtab_rfo>, describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_import_proctab_rfo>, describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_ppcksumtab_rfo>, describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_data_pages_offset>, describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_nonresnametab_offset>, describe_field_t<SgAsmLEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmLEFileHeader::p_e_debug_info_rfo>, describe_field_t<SgAsmLEFileHeader,SgAsmDOSExtendedHeader*,&SgAsmLEFileHeader::p_dos2Header>, describe_field_t<SgAsmLEFileHeader,SgAsmLESectionTable*,&SgAsmLEFileHeader::p_sectionTable>, describe_field_t<SgAsmLEFileHeader,SgAsmLEPageTable*,&SgAsmLEFileHeader::p_pageTable>, describe_field_t<SgAsmLEFileHeader,SgAsmLENameTable*,&SgAsmLEFileHeader::p_residentNameTable>, describe_field_t<SgAsmLEFileHeader,SgAsmLENameTable*,&SgAsmLEFileHeader::p_nonresidentNameTable>, describe_field_t<SgAsmLEFileHeader,SgAsmLEEntryTable*,&SgAsmLEFileHeader::p_entryTable>, describe_field_t<SgAsmLEFileHeader,SgAsmLERelocTable*,&SgAsmLEFileHeader::p_relocationTable>>;
8007};
8008template <> struct node_from_variant_t<226> { using type = SgAsmLEFileHeader; };
8009
8010// Class: AsmLENameTable
8011template <> struct describe_field_t<SgAsmLENameTable,SgStringList,&SgAsmLENameTable::p_names> {
8012 using parent = SgAsmLENameTable;
8013 using field_type = SgStringList;
8014 static constexpr size_t position{0};
8015 static constexpr char const * const name{"names"};
8016 static constexpr char const * const typestr{"SgStringList"};
8017 static constexpr bool traverse{false};
8018 static constexpr auto mbr_ptr{&SgAsmLENameTable::p_names};
8019 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8020 using bind = Desc<SgAsmLENameTable, SgStringList SgAsmLENameTable::*, &SgAsmLENameTable::p_names>;
8021};
8022template <> struct describe_field_t<SgAsmLENameTable,SgUnsignedList,&SgAsmLENameTable::p_ordinals> {
8023 using parent = SgAsmLENameTable;
8024 using field_type = SgUnsignedList;
8025 static constexpr size_t position{1};
8026 static constexpr char const * const name{"ordinals"};
8027 static constexpr char const * const typestr{"SgUnsignedList"};
8028 static constexpr bool traverse{false};
8029 static constexpr auto mbr_ptr{&SgAsmLENameTable::p_ordinals};
8030 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8031 using bind = Desc<SgAsmLENameTable, SgUnsignedList SgAsmLENameTable::*, &SgAsmLENameTable::p_ordinals>;
8032};
8034 using node = SgAsmLENameTable;
8035 using base = SgAsmGenericSection;
8036 static constexpr char const * const name{"AsmLENameTable"};
8037 static constexpr unsigned long variant{227};
8038 static constexpr bool concrete{true};
8039 using subclasses_t = mp::List<>;
8041};
8042template <> struct node_from_variant_t<227> { using type = SgAsmLENameTable; };
8043
8044// Class: AsmLEPageTable
8045template <> struct describe_field_t<SgAsmLEPageTable,SgAsmLEPageTableEntryPtrList,&SgAsmLEPageTable::p_entries> {
8046 using parent = SgAsmLEPageTable;
8047 using field_type = SgAsmLEPageTableEntryPtrList;
8048 static constexpr size_t position{0};
8049 static constexpr char const * const name{"entries"};
8050 static constexpr char const * const typestr{"SgAsmLEPageTableEntryPtrList"};
8051 static constexpr bool traverse{true};
8052 static constexpr auto mbr_ptr{&SgAsmLEPageTable::p_entries};
8053 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8054 using bind = Desc<SgAsmLEPageTable, SgAsmLEPageTableEntryPtrList SgAsmLEPageTable::*, &SgAsmLEPageTable::p_entries>;
8055};
8057 using node = SgAsmLEPageTable;
8058 using base = SgAsmGenericSection;
8059 static constexpr char const * const name{"AsmLEPageTable"};
8060 static constexpr unsigned long variant{228};
8061 static constexpr bool concrete{true};
8062 using subclasses_t = mp::List<>;
8064};
8065template <> struct node_from_variant_t<228> { using type = SgAsmLEPageTable; };
8066
8067// Class: AsmLEPageTableEntry
8068template <> struct describe_field_t<SgAsmLEPageTableEntry,unsigned,&SgAsmLEPageTableEntry::p_pageno> {
8070 using field_type = unsigned;
8071 static constexpr size_t position{0};
8072 static constexpr char const * const name{"pageno"};
8073 static constexpr char const * const typestr{"unsigned"};
8074 static constexpr bool traverse{false};
8075 static constexpr auto mbr_ptr{&SgAsmLEPageTableEntry::p_pageno};
8076 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8077 using bind = Desc<SgAsmLEPageTableEntry, unsigned SgAsmLEPageTableEntry::*, &SgAsmLEPageTableEntry::p_pageno>;
8078};
8079template <> struct describe_field_t<SgAsmLEPageTableEntry,unsigned,&SgAsmLEPageTableEntry::p_flags> {
8081 using field_type = unsigned;
8082 static constexpr size_t position{1};
8083 static constexpr char const * const name{"flags"};
8084 static constexpr char const * const typestr{"unsigned"};
8085 static constexpr bool traverse{false};
8086 static constexpr auto mbr_ptr{&SgAsmLEPageTableEntry::p_flags};
8087 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8088 using bind = Desc<SgAsmLEPageTableEntry, unsigned SgAsmLEPageTableEntry::*, &SgAsmLEPageTableEntry::p_flags>;
8089};
8093 static constexpr char const * const name{"AsmLEPageTableEntry"};
8094 static constexpr unsigned long variant{229};
8095 static constexpr bool concrete{true};
8096 using subclasses_t = mp::List<>;
8098};
8099template <> struct node_from_variant_t<229> { using type = SgAsmLEPageTableEntry; };
8100
8101// Class: AsmLERelocTable
8102template <> struct describe_field_t<SgAsmLERelocTable,SgAsmLERelocEntryPtrList,&SgAsmLERelocTable::p_entries> {
8103 using parent = SgAsmLERelocTable;
8104 using field_type = SgAsmLERelocEntryPtrList;
8105 static constexpr size_t position{0};
8106 static constexpr char const * const name{"entries"};
8107 static constexpr char const * const typestr{"SgAsmLERelocEntryPtrList"};
8108 static constexpr bool traverse{true};
8109 static constexpr auto mbr_ptr{&SgAsmLERelocTable::p_entries};
8110 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8111 using bind = Desc<SgAsmLERelocTable, SgAsmLERelocEntryPtrList SgAsmLERelocTable::*, &SgAsmLERelocTable::p_entries>;
8112};
8114 using node = SgAsmLERelocTable;
8115 using base = SgAsmGenericSection;
8116 static constexpr char const * const name{"AsmLERelocTable"};
8117 static constexpr unsigned long variant{230};
8118 static constexpr bool concrete{true};
8119 using subclasses_t = mp::List<>;
8121};
8122template <> struct node_from_variant_t<230> { using type = SgAsmLERelocTable; };
8123
8124// Class: AsmLESection
8125template <> struct describe_field_t<SgAsmLESection,SgAsmLESectionTableEntry*,&SgAsmLESection::p_sectionTableEntry> {
8126 using parent = SgAsmLESection;
8128 static constexpr size_t position{0};
8129 static constexpr char const * const name{"sectionTableEntry"};
8130 static constexpr char const * const typestr{"SgAsmLESectionTableEntry*"};
8131 static constexpr bool traverse{true};
8132 static constexpr auto mbr_ptr{&SgAsmLESection::p_sectionTableEntry};
8133 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8134 using bind = Desc<SgAsmLESection, SgAsmLESectionTableEntry* SgAsmLESection::*, &SgAsmLESection::p_sectionTableEntry>;
8135};
8136template <> struct describe_node_t<SgAsmLESection> {
8137 using node = SgAsmLESection;
8138 using base = SgAsmGenericSection;
8139 static constexpr char const * const name{"AsmLESection"};
8140 static constexpr unsigned long variant{231};
8141 static constexpr bool concrete{true};
8142 using subclasses_t = mp::List<>;
8144};
8145template <> struct node_from_variant_t<231> { using type = SgAsmLESection; };
8146
8147// Class: AsmLESectionTable
8149 using node = SgAsmLESectionTable;
8150 using base = SgAsmGenericSection;
8151 static constexpr char const * const name{"AsmLESectionTable"};
8152 static constexpr unsigned long variant{232};
8153 static constexpr bool concrete{true};
8154 using subclasses_t = mp::List<>;
8155 using fields_t = mp::List<>;
8156};
8157template <> struct node_from_variant_t<232> { using type = SgAsmLESectionTable; };
8158
8159// Class: AsmLESectionTableEntry
8160template <> struct describe_field_t<SgAsmLESectionTableEntry,unsigned,&SgAsmLESectionTableEntry::p_flags> {
8162 using field_type = unsigned;
8163 static constexpr size_t position{0};
8164 static constexpr char const * const name{"flags"};
8165 static constexpr char const * const typestr{"unsigned"};
8166 static constexpr bool traverse{false};
8167 static constexpr auto mbr_ptr{&SgAsmLESectionTableEntry::p_flags};
8168 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8169 using bind = Desc<SgAsmLESectionTableEntry, unsigned SgAsmLESectionTableEntry::*, &SgAsmLESectionTableEntry::p_flags>;
8170};
8171template <> struct describe_field_t<SgAsmLESectionTableEntry,unsigned,&SgAsmLESectionTableEntry::p_pageMapIndex> {
8173 using field_type = unsigned;
8174 static constexpr size_t position{1};
8175 static constexpr char const * const name{"pageMapIndex"};
8176 static constexpr char const * const typestr{"unsigned"};
8177 static constexpr bool traverse{false};
8178 static constexpr auto mbr_ptr{&SgAsmLESectionTableEntry::p_pageMapIndex};
8179 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8180 using bind = Desc<SgAsmLESectionTableEntry, unsigned SgAsmLESectionTableEntry::*, &SgAsmLESectionTableEntry::p_pageMapIndex>;
8181};
8182template <> struct describe_field_t<SgAsmLESectionTableEntry,unsigned,&SgAsmLESectionTableEntry::p_pageMapNEntries> {
8184 using field_type = unsigned;
8185 static constexpr size_t position{2};
8186 static constexpr char const * const name{"pageMapNEntries"};
8187 static constexpr char const * const typestr{"unsigned"};
8188 static constexpr bool traverse{false};
8189 static constexpr auto mbr_ptr{&SgAsmLESectionTableEntry::p_pageMapNEntries};
8190 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8191 using bind = Desc<SgAsmLESectionTableEntry, unsigned SgAsmLESectionTableEntry::*, &SgAsmLESectionTableEntry::p_pageMapNEntries>;
8192};
8193template <> struct describe_field_t<SgAsmLESectionTableEntry,unsigned,&SgAsmLESectionTableEntry::p_res1> {
8195 using field_type = unsigned;
8196 static constexpr size_t position{3};
8197 static constexpr char const * const name{"res1"};
8198 static constexpr char const * const typestr{"unsigned"};
8199 static constexpr bool traverse{false};
8200 static constexpr auto mbr_ptr{&SgAsmLESectionTableEntry::p_res1};
8201 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8202 using bind = Desc<SgAsmLESectionTableEntry, unsigned SgAsmLESectionTableEntry::*, &SgAsmLESectionTableEntry::p_res1>;
8203};
8204template <> struct describe_field_t<SgAsmLESectionTableEntry,Rose::BinaryAnalysis::Address,&SgAsmLESectionTableEntry::p_mappedSize> {
8206 using field_type = Rose::BinaryAnalysis::Address;
8207 static constexpr size_t position{4};
8208 static constexpr char const * const name{"mappedSize"};
8209 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
8210 static constexpr bool traverse{false};
8211 static constexpr auto mbr_ptr{&SgAsmLESectionTableEntry::p_mappedSize};
8212 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8213 using bind = Desc<SgAsmLESectionTableEntry, Rose::BinaryAnalysis::Address SgAsmLESectionTableEntry::*, &SgAsmLESectionTableEntry::p_mappedSize>;
8214};
8215template <> struct describe_field_t<SgAsmLESectionTableEntry,Rose::BinaryAnalysis::Address,&SgAsmLESectionTableEntry::p_baseAddr> {
8217 using field_type = Rose::BinaryAnalysis::Address;
8218 static constexpr size_t position{5};
8219 static constexpr char const * const name{"baseAddr"};
8220 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
8221 static constexpr bool traverse{false};
8222 static constexpr auto mbr_ptr{&SgAsmLESectionTableEntry::p_baseAddr};
8223 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8224 using bind = Desc<SgAsmLESectionTableEntry, Rose::BinaryAnalysis::Address SgAsmLESectionTableEntry::*, &SgAsmLESectionTableEntry::p_baseAddr>;
8225};
8235template <> struct node_from_variant_t<233> { using type = SgAsmLESectionTableEntry; };
8236
8237// Class: AsmM68kInstruction
8238template <> struct describe_field_t<SgAsmM68kInstruction,Rose::BinaryAnalysis::M68kInstructionKind,&SgAsmM68kInstruction::p_kind> {
8240 using field_type = Rose::BinaryAnalysis::M68kInstructionKind;
8241 static constexpr size_t position{0};
8242 static constexpr char const * const name{"kind"};
8243 static constexpr char const * const typestr{"Rose::BinaryAnalysis::M68kInstructionKind"};
8244 static constexpr bool traverse{false};
8245 static constexpr auto mbr_ptr{&SgAsmM68kInstruction::p_kind};
8246 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8247 using bind = Desc<SgAsmM68kInstruction, Rose::BinaryAnalysis::M68kInstructionKind SgAsmM68kInstruction::*, &SgAsmM68kInstruction::p_kind>;
8248};
8249template <> struct describe_field_t<SgAsmM68kInstruction,Rose::BinaryAnalysis::M68kDataFormat,&SgAsmM68kInstruction::p_dataFormat> {
8251 using field_type = Rose::BinaryAnalysis::M68kDataFormat;
8252 static constexpr size_t position{1};
8253 static constexpr char const * const name{"dataFormat"};
8254 static constexpr char const * const typestr{"Rose::BinaryAnalysis::M68kDataFormat"};
8255 static constexpr bool traverse{false};
8256 static constexpr auto mbr_ptr{&SgAsmM68kInstruction::p_dataFormat};
8257 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8258 using bind = Desc<SgAsmM68kInstruction, Rose::BinaryAnalysis::M68kDataFormat SgAsmM68kInstruction::*, &SgAsmM68kInstruction::p_dataFormat>;
8259};
8261 using node = SgAsmM68kInstruction;
8262 using base = SgAsmInstruction;
8263 static constexpr char const * const name{"AsmM68kInstruction"};
8264 static constexpr unsigned long variant{234};
8265 static constexpr bool concrete{true};
8266 using subclasses_t = mp::List<>;
8268};
8269template <> struct node_from_variant_t<234> { using type = SgAsmM68kInstruction; };
8270
8271// Class: AsmMemoryReferenceExpression
8272template <> struct describe_field_t<SgAsmMemoryReferenceExpression,SgAsmExpression*,&SgAsmMemoryReferenceExpression::p_address> {
8274 using field_type = SgAsmExpression*;
8275 static constexpr size_t position{0};
8276 static constexpr char const * const name{"address"};
8277 static constexpr char const * const typestr{"SgAsmExpression*"};
8278 static constexpr bool traverse{true};
8279 static constexpr auto mbr_ptr{&SgAsmMemoryReferenceExpression::p_address};
8280 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8281 using bind = Desc<SgAsmMemoryReferenceExpression, SgAsmExpression* SgAsmMemoryReferenceExpression::*, &SgAsmMemoryReferenceExpression::p_address>;
8282};
8283template <> struct describe_field_t<SgAsmMemoryReferenceExpression,SgAsmExpression*,&SgAsmMemoryReferenceExpression::p_segment> {
8285 using field_type = SgAsmExpression*;
8286 static constexpr size_t position{1};
8287 static constexpr char const * const name{"segment"};
8288 static constexpr char const * const typestr{"SgAsmExpression*"};
8289 static constexpr bool traverse{true};
8290 static constexpr auto mbr_ptr{&SgAsmMemoryReferenceExpression::p_segment};
8291 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8292 using bind = Desc<SgAsmMemoryReferenceExpression, SgAsmExpression* SgAsmMemoryReferenceExpression::*, &SgAsmMemoryReferenceExpression::p_segment>;
8293};
8296 using base = SgAsmExpression;
8297 static constexpr char const * const name{"AsmMemoryReferenceExpression"};
8298 static constexpr unsigned long variant{235};
8299 static constexpr bool concrete{true};
8300 using subclasses_t = mp::List<>;
8302};
8303template <> struct node_from_variant_t<235> { using type = SgAsmMemoryReferenceExpression; };
8304
8305// Class: AsmMipsInstruction
8306template <> struct describe_field_t<SgAsmMipsInstruction,Rose::BinaryAnalysis::MipsInstructionKind,&SgAsmMipsInstruction::p_kind> {
8308 using field_type = Rose::BinaryAnalysis::MipsInstructionKind;
8309 static constexpr size_t position{0};
8310 static constexpr char const * const name{"kind"};
8311 static constexpr char const * const typestr{"Rose::BinaryAnalysis::MipsInstructionKind"};
8312 static constexpr bool traverse{false};
8313 static constexpr auto mbr_ptr{&SgAsmMipsInstruction::p_kind};
8314 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8315 using bind = Desc<SgAsmMipsInstruction, Rose::BinaryAnalysis::MipsInstructionKind SgAsmMipsInstruction::*, &SgAsmMipsInstruction::p_kind>;
8316};
8318 using node = SgAsmMipsInstruction;
8319 using base = SgAsmInstruction;
8320 static constexpr char const * const name{"AsmMipsInstruction"};
8321 static constexpr unsigned long variant{236};
8322 static constexpr bool concrete{true};
8323 using subclasses_t = mp::List<>;
8325};
8326template <> struct node_from_variant_t<236> { using type = SgAsmMipsInstruction; };
8327
8328// Class: AsmNEEntryPoint
8329template <> struct describe_field_t<SgAsmNEEntryPoint,SgAsmNEEntryPoint::NEEntryFlags,&SgAsmNEEntryPoint::p_flags> {
8330 using parent = SgAsmNEEntryPoint;
8331 using field_type = SgAsmNEEntryPoint::NEEntryFlags;
8332 static constexpr size_t position{0};
8333 static constexpr char const * const name{"flags"};
8334 static constexpr char const * const typestr{"SgAsmNEEntryPoint::NEEntryFlags"};
8335 static constexpr bool traverse{false};
8336 static constexpr auto mbr_ptr{&SgAsmNEEntryPoint::p_flags};
8337 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8338 using bind = Desc<SgAsmNEEntryPoint, SgAsmNEEntryPoint::NEEntryFlags SgAsmNEEntryPoint::*, &SgAsmNEEntryPoint::p_flags>;
8339};
8340template <> struct describe_field_t<SgAsmNEEntryPoint,unsigned,&SgAsmNEEntryPoint::p_int3f> {
8341 using parent = SgAsmNEEntryPoint;
8342 using field_type = unsigned;
8343 static constexpr size_t position{1};
8344 static constexpr char const * const name{"int3f"};
8345 static constexpr char const * const typestr{"unsigned"};
8346 static constexpr bool traverse{false};
8347 static constexpr auto mbr_ptr{&SgAsmNEEntryPoint::p_int3f};
8348 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8349 using bind = Desc<SgAsmNEEntryPoint, unsigned SgAsmNEEntryPoint::*, &SgAsmNEEntryPoint::p_int3f>;
8350};
8351template <> struct describe_field_t<SgAsmNEEntryPoint,unsigned,&SgAsmNEEntryPoint::p_sectionIndex> {
8352 using parent = SgAsmNEEntryPoint;
8353 using field_type = unsigned;
8354 static constexpr size_t position{2};
8355 static constexpr char const * const name{"sectionIndex"};
8356 static constexpr char const * const typestr{"unsigned"};
8357 static constexpr bool traverse{false};
8358 static constexpr auto mbr_ptr{&SgAsmNEEntryPoint::p_sectionIndex};
8359 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8360 using bind = Desc<SgAsmNEEntryPoint, unsigned SgAsmNEEntryPoint::*, &SgAsmNEEntryPoint::p_sectionIndex>;
8361};
8362template <> struct describe_field_t<SgAsmNEEntryPoint,unsigned,&SgAsmNEEntryPoint::p_sectionOffset> {
8363 using parent = SgAsmNEEntryPoint;
8364 using field_type = unsigned;
8365 static constexpr size_t position{3};
8366 static constexpr char const * const name{"sectionOffset"};
8367 static constexpr char const * const typestr{"unsigned"};
8368 static constexpr bool traverse{false};
8369 static constexpr auto mbr_ptr{&SgAsmNEEntryPoint::p_sectionOffset};
8370 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8371 using bind = Desc<SgAsmNEEntryPoint, unsigned SgAsmNEEntryPoint::*, &SgAsmNEEntryPoint::p_sectionOffset>;
8372};
8382template <> struct node_from_variant_t<237> { using type = SgAsmNEEntryPoint; };
8383
8384// Class: AsmNEEntryTable
8385template <> struct describe_field_t<SgAsmNEEntryTable,SgSizeTList,&SgAsmNEEntryTable::p_bundle_sizes> {
8386 using parent = SgAsmNEEntryTable;
8387 using field_type = SgSizeTList;
8388 static constexpr size_t position{0};
8389 static constexpr char const * const name{"bundle_sizes"};
8390 static constexpr char const * const typestr{"SgSizeTList"};
8391 static constexpr bool traverse{false};
8392 static constexpr auto mbr_ptr{&SgAsmNEEntryTable::p_bundle_sizes};
8393 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8394 using bind = Desc<SgAsmNEEntryTable, SgSizeTList SgAsmNEEntryTable::*, &SgAsmNEEntryTable::p_bundle_sizes>;
8395};
8396template <> struct describe_field_t<SgAsmNEEntryTable,SgAsmNEEntryPointPtrList,&SgAsmNEEntryTable::p_entries> {
8397 using parent = SgAsmNEEntryTable;
8398 using field_type = SgAsmNEEntryPointPtrList;
8399 static constexpr size_t position{1};
8400 static constexpr char const * const name{"entries"};
8401 static constexpr char const * const typestr{"SgAsmNEEntryPointPtrList"};
8402 static constexpr bool traverse{true};
8403 static constexpr auto mbr_ptr{&SgAsmNEEntryTable::p_entries};
8404 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8405 using bind = Desc<SgAsmNEEntryTable, SgAsmNEEntryPointPtrList SgAsmNEEntryTable::*, &SgAsmNEEntryTable::p_entries>;
8406};
8408 using node = SgAsmNEEntryTable;
8409 using base = SgAsmGenericSection;
8410 static constexpr char const * const name{"AsmNEEntryTable"};
8411 static constexpr unsigned long variant{238};
8412 static constexpr bool concrete{true};
8413 using subclasses_t = mp::List<>;
8415};
8416template <> struct node_from_variant_t<238> { using type = SgAsmNEEntryTable; };
8417
8418// Class: AsmNEFileHeader
8419template <> struct describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_linker_major> {
8420 using parent = SgAsmNEFileHeader;
8421 using field_type = unsigned;
8422 static constexpr size_t position{0};
8423 static constexpr char const * const name{"e_linker_major"};
8424 static constexpr char const * const typestr{"unsigned"};
8425 static constexpr bool traverse{false};
8426 static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_linker_major};
8427 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8428 using bind = Desc<SgAsmNEFileHeader, unsigned SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_linker_major>;
8429};
8430template <> struct describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_linker_minor> {
8431 using parent = SgAsmNEFileHeader;
8432 using field_type = unsigned;
8433 static constexpr size_t position{1};
8434 static constexpr char const * const name{"e_linker_minor"};
8435 static constexpr char const * const typestr{"unsigned"};
8436 static constexpr bool traverse{false};
8437 static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_linker_minor};
8438 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8439 using bind = Desc<SgAsmNEFileHeader, unsigned SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_linker_minor>;
8440};
8441template <> struct describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_checksum> {
8442 using parent = SgAsmNEFileHeader;
8443 using field_type = unsigned;
8444 static constexpr size_t position{2};
8445 static constexpr char const * const name{"e_checksum"};
8446 static constexpr char const * const typestr{"unsigned"};
8447 static constexpr bool traverse{false};
8448 static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_checksum};
8449 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8450 using bind = Desc<SgAsmNEFileHeader, unsigned SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_checksum>;
8451};
8452template <> struct describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_flags1> {
8453 using parent = SgAsmNEFileHeader;
8454 using field_type = unsigned;
8455 static constexpr size_t position{3};
8456 static constexpr char const * const name{"e_flags1"};
8457 static constexpr char const * const typestr{"unsigned"};
8458 static constexpr bool traverse{false};
8459 static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_flags1};
8460 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8461 using bind = Desc<SgAsmNEFileHeader, unsigned SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_flags1>;
8462};
8463template <> struct describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_autodata_sn> {
8464 using parent = SgAsmNEFileHeader;
8465 using field_type = unsigned;
8466 static constexpr size_t position{4};
8467 static constexpr char const * const name{"e_autodata_sn"};
8468 static constexpr char const * const typestr{"unsigned"};
8469 static constexpr bool traverse{false};
8470 static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_autodata_sn};
8471 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8472 using bind = Desc<SgAsmNEFileHeader, unsigned SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_autodata_sn>;
8473};
8474template <> struct describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_bss_size> {
8475 using parent = SgAsmNEFileHeader;
8476 using field_type = unsigned;
8477 static constexpr size_t position{5};
8478 static constexpr char const * const name{"e_bss_size"};
8479 static constexpr char const * const typestr{"unsigned"};
8480 static constexpr bool traverse{false};
8481 static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_bss_size};
8482 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8483 using bind = Desc<SgAsmNEFileHeader, unsigned SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_bss_size>;
8484};
8485template <> struct describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_stack_size> {
8486 using parent = SgAsmNEFileHeader;
8487 using field_type = unsigned;
8488 static constexpr size_t position{6};
8489 static constexpr char const * const name{"e_stack_size"};
8490 static constexpr char const * const typestr{"unsigned"};
8491 static constexpr bool traverse{false};
8492 static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_stack_size};
8493 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8494 using bind = Desc<SgAsmNEFileHeader, unsigned SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_stack_size>;
8495};
8496template <> struct describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_csip> {
8497 using parent = SgAsmNEFileHeader;
8498 using field_type = unsigned;
8499 static constexpr size_t position{7};
8500 static constexpr char const * const name{"e_csip"};
8501 static constexpr char const * const typestr{"unsigned"};
8502 static constexpr bool traverse{false};
8503 static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_csip};
8504 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8505 using bind = Desc<SgAsmNEFileHeader, unsigned SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_csip>;
8506};
8507template <> struct describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_sssp> {
8508 using parent = SgAsmNEFileHeader;
8509 using field_type = unsigned;
8510 static constexpr size_t position{8};
8511 static constexpr char const * const name{"e_sssp"};
8512 static constexpr char const * const typestr{"unsigned"};
8513 static constexpr bool traverse{false};
8514 static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_sssp};
8515 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8516 using bind = Desc<SgAsmNEFileHeader, unsigned SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_sssp>;
8517};
8518template <> struct describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_nsections> {
8519 using parent = SgAsmNEFileHeader;
8520 using field_type = unsigned;
8521 static constexpr size_t position{9};
8522 static constexpr char const * const name{"e_nsections"};
8523 static constexpr char const * const typestr{"unsigned"};
8524 static constexpr bool traverse{false};
8525 static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_nsections};
8526 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8527 using bind = Desc<SgAsmNEFileHeader, unsigned SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_nsections>;
8528};
8529template <> struct describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_nmodrefs> {
8530 using parent = SgAsmNEFileHeader;
8531 using field_type = unsigned;
8532 static constexpr size_t position{10};
8533 static constexpr char const * const name{"e_nmodrefs"};
8534 static constexpr char const * const typestr{"unsigned"};
8535 static constexpr bool traverse{false};
8536 static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_nmodrefs};
8537 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8538 using bind = Desc<SgAsmNEFileHeader, unsigned SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_nmodrefs>;
8539};
8540template <> struct describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_nnonresnames> {
8541 using parent = SgAsmNEFileHeader;
8542 using field_type = unsigned;
8543 static constexpr size_t position{11};
8544 static constexpr char const * const name{"e_nnonresnames"};
8545 static constexpr char const * const typestr{"unsigned"};
8546 static constexpr bool traverse{false};
8547 static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_nnonresnames};
8548 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8549 using bind = Desc<SgAsmNEFileHeader, unsigned SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_nnonresnames>;
8550};
8551template <> struct describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_nmovable_entries> {
8552 using parent = SgAsmNEFileHeader;
8553 using field_type = unsigned;
8554 static constexpr size_t position{12};
8555 static constexpr char const * const name{"e_nmovable_entries"};
8556 static constexpr char const * const typestr{"unsigned"};
8557 static constexpr bool traverse{false};
8558 static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_nmovable_entries};
8559 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8560 using bind = Desc<SgAsmNEFileHeader, unsigned SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_nmovable_entries>;
8561};
8562template <> struct describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_sector_align> {
8563 using parent = SgAsmNEFileHeader;
8564 using field_type = unsigned;
8565 static constexpr size_t position{13};
8566 static constexpr char const * const name{"e_sector_align"};
8567 static constexpr char const * const typestr{"unsigned"};
8568 static constexpr bool traverse{false};
8569 static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_sector_align};
8570 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8571 using bind = Desc<SgAsmNEFileHeader, unsigned SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_sector_align>;
8572};
8573template <> struct describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_nresources> {
8574 using parent = SgAsmNEFileHeader;
8575 using field_type = unsigned;
8576 static constexpr size_t position{14};
8577 static constexpr char const * const name{"e_nresources"};
8578 static constexpr char const * const typestr{"unsigned"};
8579 static constexpr bool traverse{false};
8580 static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_nresources};
8581 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8582 using bind = Desc<SgAsmNEFileHeader, unsigned SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_nresources>;
8583};
8584template <> struct describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_exetype> {
8585 using parent = SgAsmNEFileHeader;
8586 using field_type = unsigned;
8587 static constexpr size_t position{15};
8588 static constexpr char const * const name{"e_exetype"};
8589 static constexpr char const * const typestr{"unsigned"};
8590 static constexpr bool traverse{false};
8591 static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_exetype};
8592 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8593 using bind = Desc<SgAsmNEFileHeader, unsigned SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_exetype>;
8594};
8595template <> struct describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_flags2> {
8596 using parent = SgAsmNEFileHeader;
8597 using field_type = unsigned;
8598 static constexpr size_t position{16};
8599 static constexpr char const * const name{"e_flags2"};
8600 static constexpr char const * const typestr{"unsigned"};
8601 static constexpr bool traverse{false};
8602 static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_flags2};
8603 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8604 using bind = Desc<SgAsmNEFileHeader, unsigned SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_flags2>;
8605};
8606template <> struct describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_res1> {
8607 using parent = SgAsmNEFileHeader;
8608 using field_type = unsigned;
8609 static constexpr size_t position{17};
8610 static constexpr char const * const name{"e_res1"};
8611 static constexpr char const * const typestr{"unsigned"};
8612 static constexpr bool traverse{false};
8613 static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_res1};
8614 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8615 using bind = Desc<SgAsmNEFileHeader, unsigned SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_res1>;
8616};
8617template <> struct describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_winvers> {
8618 using parent = SgAsmNEFileHeader;
8619 using field_type = unsigned;
8620 static constexpr size_t position{18};
8621 static constexpr char const * const name{"e_winvers"};
8622 static constexpr char const * const typestr{"unsigned"};
8623 static constexpr bool traverse{false};
8624 static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_winvers};
8625 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8626 using bind = Desc<SgAsmNEFileHeader, unsigned SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_winvers>;
8627};
8628template <> struct describe_field_t<SgAsmNEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmNEFileHeader::p_e_entrytab_rfo> {
8629 using parent = SgAsmNEFileHeader;
8630 using field_type = Rose::BinaryAnalysis::Address;
8631 static constexpr size_t position{19};
8632 static constexpr char const * const name{"e_entrytab_rfo"};
8633 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
8634 static constexpr bool traverse{false};
8635 static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_entrytab_rfo};
8636 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8637 using bind = Desc<SgAsmNEFileHeader, Rose::BinaryAnalysis::Address SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_entrytab_rfo>;
8638};
8639template <> struct describe_field_t<SgAsmNEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmNEFileHeader::p_e_entrytab_size> {
8640 using parent = SgAsmNEFileHeader;
8641 using field_type = Rose::BinaryAnalysis::Address;
8642 static constexpr size_t position{20};
8643 static constexpr char const * const name{"e_entrytab_size"};
8644 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
8645 static constexpr bool traverse{false};
8646 static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_entrytab_size};
8647 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8648 using bind = Desc<SgAsmNEFileHeader, Rose::BinaryAnalysis::Address SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_entrytab_size>;
8649};
8650template <> struct describe_field_t<SgAsmNEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmNEFileHeader::p_e_sectab_rfo> {
8651 using parent = SgAsmNEFileHeader;
8652 using field_type = Rose::BinaryAnalysis::Address;
8653 static constexpr size_t position{21};
8654 static constexpr char const * const name{"e_sectab_rfo"};
8655 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
8656 static constexpr bool traverse{false};
8657 static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_sectab_rfo};
8658 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8659 using bind = Desc<SgAsmNEFileHeader, Rose::BinaryAnalysis::Address SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_sectab_rfo>;
8660};
8661template <> struct describe_field_t<SgAsmNEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmNEFileHeader::p_e_rsrctab_rfo> {
8662 using parent = SgAsmNEFileHeader;
8663 using field_type = Rose::BinaryAnalysis::Address;
8664 static constexpr size_t position{22};
8665 static constexpr char const * const name{"e_rsrctab_rfo"};
8666 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
8667 static constexpr bool traverse{false};
8668 static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_rsrctab_rfo};
8669 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8670 using bind = Desc<SgAsmNEFileHeader, Rose::BinaryAnalysis::Address SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_rsrctab_rfo>;
8671};
8672template <> struct describe_field_t<SgAsmNEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmNEFileHeader::p_e_resnametab_rfo> {
8673 using parent = SgAsmNEFileHeader;
8674 using field_type = Rose::BinaryAnalysis::Address;
8675 static constexpr size_t position{23};
8676 static constexpr char const * const name{"e_resnametab_rfo"};
8677 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
8678 static constexpr bool traverse{false};
8679 static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_resnametab_rfo};
8680 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8681 using bind = Desc<SgAsmNEFileHeader, Rose::BinaryAnalysis::Address SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_resnametab_rfo>;
8682};
8683template <> struct describe_field_t<SgAsmNEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmNEFileHeader::p_e_modreftab_rfo> {
8684 using parent = SgAsmNEFileHeader;
8685 using field_type = Rose::BinaryAnalysis::Address;
8686 static constexpr size_t position{24};
8687 static constexpr char const * const name{"e_modreftab_rfo"};
8688 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
8689 static constexpr bool traverse{false};
8690 static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_modreftab_rfo};
8691 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8692 using bind = Desc<SgAsmNEFileHeader, Rose::BinaryAnalysis::Address SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_modreftab_rfo>;
8693};
8694template <> struct describe_field_t<SgAsmNEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmNEFileHeader::p_e_importnametab_rfo> {
8695 using parent = SgAsmNEFileHeader;
8696 using field_type = Rose::BinaryAnalysis::Address;
8697 static constexpr size_t position{25};
8698 static constexpr char const * const name{"e_importnametab_rfo"};
8699 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
8700 static constexpr bool traverse{false};
8701 static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_importnametab_rfo};
8702 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8703 using bind = Desc<SgAsmNEFileHeader, Rose::BinaryAnalysis::Address SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_importnametab_rfo>;
8704};
8705template <> struct describe_field_t<SgAsmNEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmNEFileHeader::p_e_nonresnametab_offset> {
8706 using parent = SgAsmNEFileHeader;
8707 using field_type = Rose::BinaryAnalysis::Address;
8708 static constexpr size_t position{26};
8709 static constexpr char const * const name{"e_nonresnametab_offset"};
8710 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
8711 static constexpr bool traverse{false};
8712 static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_nonresnametab_offset};
8713 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8714 using bind = Desc<SgAsmNEFileHeader, Rose::BinaryAnalysis::Address SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_nonresnametab_offset>;
8715};
8716template <> struct describe_field_t<SgAsmNEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmNEFileHeader::p_e_fastload_sector> {
8717 using parent = SgAsmNEFileHeader;
8718 using field_type = Rose::BinaryAnalysis::Address;
8719 static constexpr size_t position{27};
8720 static constexpr char const * const name{"e_fastload_sector"};
8721 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
8722 static constexpr bool traverse{false};
8723 static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_fastload_sector};
8724 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8725 using bind = Desc<SgAsmNEFileHeader, Rose::BinaryAnalysis::Address SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_fastload_sector>;
8726};
8727template <> struct describe_field_t<SgAsmNEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmNEFileHeader::p_e_fastload_nsectors> {
8728 using parent = SgAsmNEFileHeader;
8729 using field_type = Rose::BinaryAnalysis::Address;
8730 static constexpr size_t position{28};
8731 static constexpr char const * const name{"e_fastload_nsectors"};
8732 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
8733 static constexpr bool traverse{false};
8734 static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_e_fastload_nsectors};
8735 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8736 using bind = Desc<SgAsmNEFileHeader, Rose::BinaryAnalysis::Address SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_e_fastload_nsectors>;
8737};
8738template <> struct describe_field_t<SgAsmNEFileHeader,SgAsmDOSExtendedHeader*,&SgAsmNEFileHeader::p_dos2Header> {
8739 using parent = SgAsmNEFileHeader;
8741 static constexpr size_t position{29};
8742 static constexpr char const * const name{"dos2Header"};
8743 static constexpr char const * const typestr{"SgAsmDOSExtendedHeader*"};
8744 static constexpr bool traverse{true};
8745 static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_dos2Header};
8746 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8747 using bind = Desc<SgAsmNEFileHeader, SgAsmDOSExtendedHeader* SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_dos2Header>;
8748};
8749template <> struct describe_field_t<SgAsmNEFileHeader,SgAsmNESectionTable*,&SgAsmNEFileHeader::p_sectionTable> {
8750 using parent = SgAsmNEFileHeader;
8752 static constexpr size_t position{30};
8753 static constexpr char const * const name{"sectionTable"};
8754 static constexpr char const * const typestr{"SgAsmNESectionTable*"};
8755 static constexpr bool traverse{false};
8756 static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_sectionTable};
8757 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8758 using bind = Desc<SgAsmNEFileHeader, SgAsmNESectionTable* SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_sectionTable>;
8759};
8760template <> struct describe_field_t<SgAsmNEFileHeader,SgAsmNENameTable*,&SgAsmNEFileHeader::p_residentNameTable> {
8761 using parent = SgAsmNEFileHeader;
8763 static constexpr size_t position{31};
8764 static constexpr char const * const name{"residentNameTable"};
8765 static constexpr char const * const typestr{"SgAsmNENameTable*"};
8766 static constexpr bool traverse{true};
8767 static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_residentNameTable};
8768 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8769 using bind = Desc<SgAsmNEFileHeader, SgAsmNENameTable* SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_residentNameTable>;
8770};
8771template <> struct describe_field_t<SgAsmNEFileHeader,SgAsmNENameTable*,&SgAsmNEFileHeader::p_nonresidentNameTable> {
8772 using parent = SgAsmNEFileHeader;
8774 static constexpr size_t position{32};
8775 static constexpr char const * const name{"nonresidentNameTable"};
8776 static constexpr char const * const typestr{"SgAsmNENameTable*"};
8777 static constexpr bool traverse{true};
8778 static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_nonresidentNameTable};
8779 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8780 using bind = Desc<SgAsmNEFileHeader, SgAsmNENameTable* SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_nonresidentNameTable>;
8781};
8782template <> struct describe_field_t<SgAsmNEFileHeader,SgAsmNEModuleTable*,&SgAsmNEFileHeader::p_moduleTable> {
8783 using parent = SgAsmNEFileHeader;
8785 static constexpr size_t position{33};
8786 static constexpr char const * const name{"moduleTable"};
8787 static constexpr char const * const typestr{"SgAsmNEModuleTable*"};
8788 static constexpr bool traverse{true};
8789 static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_moduleTable};
8790 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8791 using bind = Desc<SgAsmNEFileHeader, SgAsmNEModuleTable* SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_moduleTable>;
8792};
8793template <> struct describe_field_t<SgAsmNEFileHeader,SgAsmNEEntryTable*,&SgAsmNEFileHeader::p_entryTable> {
8794 using parent = SgAsmNEFileHeader;
8796 static constexpr size_t position{34};
8797 static constexpr char const * const name{"entryTable"};
8798 static constexpr char const * const typestr{"SgAsmNEEntryTable*"};
8799 static constexpr bool traverse{true};
8800 static constexpr auto mbr_ptr{&SgAsmNEFileHeader::p_entryTable};
8801 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8802 using bind = Desc<SgAsmNEFileHeader, SgAsmNEEntryTable* SgAsmNEFileHeader::*, &SgAsmNEFileHeader::p_entryTable>;
8803};
8805 using node = SgAsmNEFileHeader;
8806 using base = SgAsmGenericHeader;
8807 static constexpr char const * const name{"AsmNEFileHeader"};
8808 static constexpr unsigned long variant{239};
8809 static constexpr bool concrete{true};
8810 using subclasses_t = mp::List<>;
8811 using fields_t = mp::List<describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_linker_major>, describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_linker_minor>, describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_checksum>, describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_flags1>, describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_autodata_sn>, describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_bss_size>, describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_stack_size>, describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_csip>, describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_sssp>, describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_nsections>, describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_nmodrefs>, describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_nnonresnames>, describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_nmovable_entries>, describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_sector_align>, describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_nresources>, describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_exetype>, describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_flags2>, describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_res1>, describe_field_t<SgAsmNEFileHeader,unsigned,&SgAsmNEFileHeader::p_e_winvers>, describe_field_t<SgAsmNEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmNEFileHeader::p_e_entrytab_rfo>, describe_field_t<SgAsmNEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmNEFileHeader::p_e_entrytab_size>, describe_field_t<SgAsmNEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmNEFileHeader::p_e_sectab_rfo>, describe_field_t<SgAsmNEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmNEFileHeader::p_e_rsrctab_rfo>, describe_field_t<SgAsmNEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmNEFileHeader::p_e_resnametab_rfo>, describe_field_t<SgAsmNEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmNEFileHeader::p_e_modreftab_rfo>, describe_field_t<SgAsmNEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmNEFileHeader::p_e_importnametab_rfo>, describe_field_t<SgAsmNEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmNEFileHeader::p_e_nonresnametab_offset>, describe_field_t<SgAsmNEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmNEFileHeader::p_e_fastload_sector>, describe_field_t<SgAsmNEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmNEFileHeader::p_e_fastload_nsectors>, describe_field_t<SgAsmNEFileHeader,SgAsmDOSExtendedHeader*,&SgAsmNEFileHeader::p_dos2Header>, describe_field_t<SgAsmNEFileHeader,SgAsmNESectionTable*,&SgAsmNEFileHeader::p_sectionTable>, describe_field_t<SgAsmNEFileHeader,SgAsmNENameTable*,&SgAsmNEFileHeader::p_residentNameTable>, describe_field_t<SgAsmNEFileHeader,SgAsmNENameTable*,&SgAsmNEFileHeader::p_nonresidentNameTable>, describe_field_t<SgAsmNEFileHeader,SgAsmNEModuleTable*,&SgAsmNEFileHeader::p_moduleTable>, describe_field_t<SgAsmNEFileHeader,SgAsmNEEntryTable*,&SgAsmNEFileHeader::p_entryTable>>;
8812};
8813template <> struct node_from_variant_t<239> { using type = SgAsmNEFileHeader; };
8814
8815// Class: AsmNEModuleTable
8816template <> struct describe_field_t<SgAsmNEModuleTable,SgAsmNEStringTable*,&SgAsmNEModuleTable::p_strtab> {
8817 using parent = SgAsmNEModuleTable;
8819 static constexpr size_t position{0};
8820 static constexpr char const * const name{"strtab"};
8821 static constexpr char const * const typestr{"SgAsmNEStringTable*"};
8822 static constexpr bool traverse{true};
8823 static constexpr auto mbr_ptr{&SgAsmNEModuleTable::p_strtab};
8824 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8825 using bind = Desc<SgAsmNEModuleTable, SgAsmNEStringTable* SgAsmNEModuleTable::*, &SgAsmNEModuleTable::p_strtab>;
8826};
8827template <> struct describe_field_t<SgAsmNEModuleTable,SgAddressList,&SgAsmNEModuleTable::p_nameOffsets> {
8828 using parent = SgAsmNEModuleTable;
8829 using field_type = SgAddressList;
8830 static constexpr size_t position{1};
8831 static constexpr char const * const name{"nameOffsets"};
8832 static constexpr char const * const typestr{"SgAddressList"};
8833 static constexpr bool traverse{false};
8834 static constexpr auto mbr_ptr{&SgAsmNEModuleTable::p_nameOffsets};
8835 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8836 using bind = Desc<SgAsmNEModuleTable, SgAddressList SgAsmNEModuleTable::*, &SgAsmNEModuleTable::p_nameOffsets>;
8837};
8838template <> struct describe_field_t<SgAsmNEModuleTable,SgStringList,&SgAsmNEModuleTable::p_names> {
8839 using parent = SgAsmNEModuleTable;
8840 using field_type = SgStringList;
8841 static constexpr size_t position{2};
8842 static constexpr char const * const name{"names"};
8843 static constexpr char const * const typestr{"SgStringList"};
8844 static constexpr bool traverse{false};
8845 static constexpr auto mbr_ptr{&SgAsmNEModuleTable::p_names};
8846 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8847 using bind = Desc<SgAsmNEModuleTable, SgStringList SgAsmNEModuleTable::*, &SgAsmNEModuleTable::p_names>;
8848};
8850 using node = SgAsmNEModuleTable;
8851 using base = SgAsmGenericSection;
8852 static constexpr char const * const name{"AsmNEModuleTable"};
8853 static constexpr unsigned long variant{240};
8854 static constexpr bool concrete{true};
8855 using subclasses_t = mp::List<>;
8857};
8858template <> struct node_from_variant_t<240> { using type = SgAsmNEModuleTable; };
8859
8860// Class: AsmNENameTable
8861template <> struct describe_field_t<SgAsmNENameTable,SgStringList,&SgAsmNENameTable::p_names> {
8862 using parent = SgAsmNENameTable;
8863 using field_type = SgStringList;
8864 static constexpr size_t position{0};
8865 static constexpr char const * const name{"names"};
8866 static constexpr char const * const typestr{"SgStringList"};
8867 static constexpr bool traverse{false};
8868 static constexpr auto mbr_ptr{&SgAsmNENameTable::p_names};
8869 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8870 using bind = Desc<SgAsmNENameTable, SgStringList SgAsmNENameTable::*, &SgAsmNENameTable::p_names>;
8871};
8872template <> struct describe_field_t<SgAsmNENameTable,SgUnsignedList,&SgAsmNENameTable::p_ordinals> {
8873 using parent = SgAsmNENameTable;
8874 using field_type = SgUnsignedList;
8875 static constexpr size_t position{1};
8876 static constexpr char const * const name{"ordinals"};
8877 static constexpr char const * const typestr{"SgUnsignedList"};
8878 static constexpr bool traverse{false};
8879 static constexpr auto mbr_ptr{&SgAsmNENameTable::p_ordinals};
8880 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8881 using bind = Desc<SgAsmNENameTable, SgUnsignedList SgAsmNENameTable::*, &SgAsmNENameTable::p_ordinals>;
8882};
8884 using node = SgAsmNENameTable;
8885 using base = SgAsmGenericSection;
8886 static constexpr char const * const name{"AsmNENameTable"};
8887 static constexpr unsigned long variant{241};
8888 static constexpr bool concrete{true};
8889 using subclasses_t = mp::List<>;
8891};
8892template <> struct node_from_variant_t<241> { using type = SgAsmNENameTable; };
8893
8894// Class: AsmNERelocEntry
8895template <> struct describe_field_t<SgAsmNERelocEntry,SgAsmNERelocEntry::NERelocSrcType,&SgAsmNERelocEntry::p_src_type> {
8896 using parent = SgAsmNERelocEntry;
8897 using field_type = SgAsmNERelocEntry::NERelocSrcType;
8898 static constexpr size_t position{0};
8899 static constexpr char const * const name{"src_type"};
8900 static constexpr char const * const typestr{"SgAsmNERelocEntry::NERelocSrcType"};
8901 static constexpr bool traverse{false};
8902 static constexpr auto mbr_ptr{&SgAsmNERelocEntry::p_src_type};
8903 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8904 using bind = Desc<SgAsmNERelocEntry, SgAsmNERelocEntry::NERelocSrcType SgAsmNERelocEntry::*, &SgAsmNERelocEntry::p_src_type>;
8905};
8906template <> struct describe_field_t<SgAsmNERelocEntry,SgAsmNERelocEntry::NERelocModifiers,&SgAsmNERelocEntry::p_modifier> {
8907 using parent = SgAsmNERelocEntry;
8908 using field_type = SgAsmNERelocEntry::NERelocModifiers;
8909 static constexpr size_t position{1};
8910 static constexpr char const * const name{"modifier"};
8911 static constexpr char const * const typestr{"SgAsmNERelocEntry::NERelocModifiers"};
8912 static constexpr bool traverse{false};
8913 static constexpr auto mbr_ptr{&SgAsmNERelocEntry::p_modifier};
8914 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8915 using bind = Desc<SgAsmNERelocEntry, SgAsmNERelocEntry::NERelocModifiers SgAsmNERelocEntry::*, &SgAsmNERelocEntry::p_modifier>;
8916};
8917template <> struct describe_field_t<SgAsmNERelocEntry,SgAsmNERelocEntry::NERelocTgtType,&SgAsmNERelocEntry::p_tgt_type> {
8918 using parent = SgAsmNERelocEntry;
8919 using field_type = SgAsmNERelocEntry::NERelocTgtType;
8920 static constexpr size_t position{2};
8921 static constexpr char const * const name{"tgt_type"};
8922 static constexpr char const * const typestr{"SgAsmNERelocEntry::NERelocTgtType"};
8923 static constexpr bool traverse{false};
8924 static constexpr auto mbr_ptr{&SgAsmNERelocEntry::p_tgt_type};
8925 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8926 using bind = Desc<SgAsmNERelocEntry, SgAsmNERelocEntry::NERelocTgtType SgAsmNERelocEntry::*, &SgAsmNERelocEntry::p_tgt_type>;
8927};
8928template <> struct describe_field_t<SgAsmNERelocEntry,SgAsmNERelocEntry::NERelocFlags,&SgAsmNERelocEntry::p_flags> {
8929 using parent = SgAsmNERelocEntry;
8930 using field_type = SgAsmNERelocEntry::NERelocFlags;
8931 static constexpr size_t position{3};
8932 static constexpr char const * const name{"flags"};
8933 static constexpr char const * const typestr{"SgAsmNERelocEntry::NERelocFlags"};
8934 static constexpr bool traverse{false};
8935 static constexpr auto mbr_ptr{&SgAsmNERelocEntry::p_flags};
8936 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8937 using bind = Desc<SgAsmNERelocEntry, SgAsmNERelocEntry::NERelocFlags SgAsmNERelocEntry::*, &SgAsmNERelocEntry::p_flags>;
8938};
8939template <> struct describe_field_t<SgAsmNERelocEntry,Rose::BinaryAnalysis::Address,&SgAsmNERelocEntry::p_src_offset> {
8940 using parent = SgAsmNERelocEntry;
8941 using field_type = Rose::BinaryAnalysis::Address;
8942 static constexpr size_t position{4};
8943 static constexpr char const * const name{"src_offset"};
8944 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
8945 static constexpr bool traverse{false};
8946 static constexpr auto mbr_ptr{&SgAsmNERelocEntry::p_src_offset};
8947 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8948 using bind = Desc<SgAsmNERelocEntry, Rose::BinaryAnalysis::Address SgAsmNERelocEntry::*, &SgAsmNERelocEntry::p_src_offset>;
8949};
8950template <> struct describe_field_t<SgAsmNERelocEntry,SgAsmNERelocEntry::iref_type,&SgAsmNERelocEntry::p_iref> {
8951 using parent = SgAsmNERelocEntry;
8953 static constexpr size_t position{5};
8954 static constexpr char const * const name{"iref"};
8955 static constexpr char const * const typestr{"SgAsmNERelocEntry::iref_type"};
8956 static constexpr bool traverse{false};
8957 static constexpr auto mbr_ptr{&SgAsmNERelocEntry::p_iref};
8958 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8959 using bind = Desc<SgAsmNERelocEntry, SgAsmNERelocEntry::iref_type SgAsmNERelocEntry::*, &SgAsmNERelocEntry::p_iref>;
8960};
8961template <> struct describe_field_t<SgAsmNERelocEntry,SgAsmNERelocEntry::iord_type,&SgAsmNERelocEntry::p_iord> {
8962 using parent = SgAsmNERelocEntry;
8964 static constexpr size_t position{6};
8965 static constexpr char const * const name{"iord"};
8966 static constexpr char const * const typestr{"SgAsmNERelocEntry::iord_type"};
8967 static constexpr bool traverse{false};
8968 static constexpr auto mbr_ptr{&SgAsmNERelocEntry::p_iord};
8969 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8970 using bind = Desc<SgAsmNERelocEntry, SgAsmNERelocEntry::iord_type SgAsmNERelocEntry::*, &SgAsmNERelocEntry::p_iord>;
8971};
8972template <> struct describe_field_t<SgAsmNERelocEntry,SgAsmNERelocEntry::iname_type,&SgAsmNERelocEntry::p_iname> {
8973 using parent = SgAsmNERelocEntry;
8975 static constexpr size_t position{7};
8976 static constexpr char const * const name{"iname"};
8977 static constexpr char const * const typestr{"SgAsmNERelocEntry::iname_type"};
8978 static constexpr bool traverse{false};
8979 static constexpr auto mbr_ptr{&SgAsmNERelocEntry::p_iname};
8980 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8981 using bind = Desc<SgAsmNERelocEntry, SgAsmNERelocEntry::iname_type SgAsmNERelocEntry::*, &SgAsmNERelocEntry::p_iname>;
8982};
8983template <> struct describe_field_t<SgAsmNERelocEntry,SgAsmNERelocEntry::osfixup_type,&SgAsmNERelocEntry::p_osfixup> {
8984 using parent = SgAsmNERelocEntry;
8986 static constexpr size_t position{8};
8987 static constexpr char const * const name{"osfixup"};
8988 static constexpr char const * const typestr{"SgAsmNERelocEntry::osfixup_type"};
8989 static constexpr bool traverse{false};
8990 static constexpr auto mbr_ptr{&SgAsmNERelocEntry::p_osfixup};
8991 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
8992 using bind = Desc<SgAsmNERelocEntry, SgAsmNERelocEntry::osfixup_type SgAsmNERelocEntry::*, &SgAsmNERelocEntry::p_osfixup>;
8993};
9003template <> struct node_from_variant_t<242> { using type = SgAsmNERelocEntry; };
9004
9005// Class: AsmNERelocTable
9006template <> struct describe_field_t<SgAsmNERelocTable,SgAsmNERelocEntryPtrList,&SgAsmNERelocTable::p_entries> {
9007 using parent = SgAsmNERelocTable;
9008 using field_type = SgAsmNERelocEntryPtrList;
9009 static constexpr size_t position{0};
9010 static constexpr char const * const name{"entries"};
9011 static constexpr char const * const typestr{"SgAsmNERelocEntryPtrList"};
9012 static constexpr bool traverse{true};
9013 static constexpr auto mbr_ptr{&SgAsmNERelocTable::p_entries};
9014 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9015 using bind = Desc<SgAsmNERelocTable, SgAsmNERelocEntryPtrList SgAsmNERelocTable::*, &SgAsmNERelocTable::p_entries>;
9016};
9018 using node = SgAsmNERelocTable;
9019 using base = SgAsmGenericSection;
9020 static constexpr char const * const name{"AsmNERelocTable"};
9021 static constexpr unsigned long variant{243};
9022 static constexpr bool concrete{true};
9023 using subclasses_t = mp::List<>;
9025};
9026template <> struct node_from_variant_t<243> { using type = SgAsmNERelocTable; };
9027
9028// Class: AsmNESection
9029template <> struct describe_field_t<SgAsmNESection,SgAsmNESectionTableEntry*,&SgAsmNESection::p_sectionTableEntry> {
9030 using parent = SgAsmNESection;
9032 static constexpr size_t position{0};
9033 static constexpr char const * const name{"sectionTableEntry"};
9034 static constexpr char const * const typestr{"SgAsmNESectionTableEntry*"};
9035 static constexpr bool traverse{true};
9036 static constexpr auto mbr_ptr{&SgAsmNESection::p_sectionTableEntry};
9037 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9038 using bind = Desc<SgAsmNESection, SgAsmNESectionTableEntry* SgAsmNESection::*, &SgAsmNESection::p_sectionTableEntry>;
9039};
9040template <> struct describe_field_t<SgAsmNESection,SgAsmNERelocTable*,&SgAsmNESection::p_relocationTable> {
9041 using parent = SgAsmNESection;
9043 static constexpr size_t position{1};
9044 static constexpr char const * const name{"relocationTable"};
9045 static constexpr char const * const typestr{"SgAsmNERelocTable*"};
9046 static constexpr bool traverse{true};
9047 static constexpr auto mbr_ptr{&SgAsmNESection::p_relocationTable};
9048 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9049 using bind = Desc<SgAsmNESection, SgAsmNERelocTable* SgAsmNESection::*, &SgAsmNESection::p_relocationTable>;
9050};
9051template <> struct describe_node_t<SgAsmNESection> {
9052 using node = SgAsmNESection;
9053 using base = SgAsmGenericSection;
9054 static constexpr char const * const name{"AsmNESection"};
9055 static constexpr unsigned long variant{244};
9056 static constexpr bool concrete{true};
9057 using subclasses_t = mp::List<>;
9059};
9060template <> struct node_from_variant_t<244> { using type = SgAsmNESection; };
9061
9062// Class: AsmNESectionTable
9063template <> struct describe_field_t<SgAsmNESectionTable,unsigned,&SgAsmNESectionTable::p_flags> {
9065 using field_type = unsigned;
9066 static constexpr size_t position{0};
9067 static constexpr char const * const name{"flags"};
9068 static constexpr char const * const typestr{"unsigned"};
9069 static constexpr bool traverse{false};
9070 static constexpr auto mbr_ptr{&SgAsmNESectionTable::p_flags};
9071 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9072 using bind = Desc<SgAsmNESectionTable, unsigned SgAsmNESectionTable::*, &SgAsmNESectionTable::p_flags>;
9073};
9074template <> struct describe_field_t<SgAsmNESectionTable,unsigned,&SgAsmNESectionTable::p_sector> {
9076 using field_type = unsigned;
9077 static constexpr size_t position{1};
9078 static constexpr char const * const name{"sector"};
9079 static constexpr char const * const typestr{"unsigned"};
9080 static constexpr bool traverse{false};
9081 static constexpr auto mbr_ptr{&SgAsmNESectionTable::p_sector};
9082 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9083 using bind = Desc<SgAsmNESectionTable, unsigned SgAsmNESectionTable::*, &SgAsmNESectionTable::p_sector>;
9084};
9085template <> struct describe_field_t<SgAsmNESectionTable,Rose::BinaryAnalysis::Address,&SgAsmNESectionTable::p_physicalSize> {
9087 using field_type = Rose::BinaryAnalysis::Address;
9088 static constexpr size_t position{2};
9089 static constexpr char const * const name{"physicalSize"};
9090 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
9091 static constexpr bool traverse{false};
9092 static constexpr auto mbr_ptr{&SgAsmNESectionTable::p_physicalSize};
9093 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9094 using bind = Desc<SgAsmNESectionTable, Rose::BinaryAnalysis::Address SgAsmNESectionTable::*, &SgAsmNESectionTable::p_physicalSize>;
9095};
9096template <> struct describe_field_t<SgAsmNESectionTable,Rose::BinaryAnalysis::Address,&SgAsmNESectionTable::p_virtualSize> {
9098 using field_type = Rose::BinaryAnalysis::Address;
9099 static constexpr size_t position{3};
9100 static constexpr char const * const name{"virtualSize"};
9101 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
9102 static constexpr bool traverse{false};
9103 static constexpr auto mbr_ptr{&SgAsmNESectionTable::p_virtualSize};
9104 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9105 using bind = Desc<SgAsmNESectionTable, Rose::BinaryAnalysis::Address SgAsmNESectionTable::*, &SgAsmNESectionTable::p_virtualSize>;
9106};
9116template <> struct node_from_variant_t<245> { using type = SgAsmNESectionTable; };
9117
9118// Class: AsmNESectionTableEntry
9119template <> struct describe_field_t<SgAsmNESectionTableEntry,unsigned,&SgAsmNESectionTableEntry::p_flags> {
9121 using field_type = unsigned;
9122 static constexpr size_t position{0};
9123 static constexpr char const * const name{"flags"};
9124 static constexpr char const * const typestr{"unsigned"};
9125 static constexpr bool traverse{false};
9126 static constexpr auto mbr_ptr{&SgAsmNESectionTableEntry::p_flags};
9127 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9128 using bind = Desc<SgAsmNESectionTableEntry, unsigned SgAsmNESectionTableEntry::*, &SgAsmNESectionTableEntry::p_flags>;
9129};
9130template <> struct describe_field_t<SgAsmNESectionTableEntry,unsigned,&SgAsmNESectionTableEntry::p_sector> {
9132 using field_type = unsigned;
9133 static constexpr size_t position{1};
9134 static constexpr char const * const name{"sector"};
9135 static constexpr char const * const typestr{"unsigned"};
9136 static constexpr bool traverse{false};
9137 static constexpr auto mbr_ptr{&SgAsmNESectionTableEntry::p_sector};
9138 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9139 using bind = Desc<SgAsmNESectionTableEntry, unsigned SgAsmNESectionTableEntry::*, &SgAsmNESectionTableEntry::p_sector>;
9140};
9141template <> struct describe_field_t<SgAsmNESectionTableEntry,Rose::BinaryAnalysis::Address,&SgAsmNESectionTableEntry::p_physicalSize> {
9143 using field_type = Rose::BinaryAnalysis::Address;
9144 static constexpr size_t position{2};
9145 static constexpr char const * const name{"physicalSize"};
9146 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
9147 static constexpr bool traverse{false};
9148 static constexpr auto mbr_ptr{&SgAsmNESectionTableEntry::p_physicalSize};
9149 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9150 using bind = Desc<SgAsmNESectionTableEntry, Rose::BinaryAnalysis::Address SgAsmNESectionTableEntry::*, &SgAsmNESectionTableEntry::p_physicalSize>;
9151};
9152template <> struct describe_field_t<SgAsmNESectionTableEntry,Rose::BinaryAnalysis::Address,&SgAsmNESectionTableEntry::p_virtualSize> {
9154 using field_type = Rose::BinaryAnalysis::Address;
9155 static constexpr size_t position{3};
9156 static constexpr char const * const name{"virtualSize"};
9157 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
9158 static constexpr bool traverse{false};
9159 static constexpr auto mbr_ptr{&SgAsmNESectionTableEntry::p_virtualSize};
9160 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9161 using bind = Desc<SgAsmNESectionTableEntry, Rose::BinaryAnalysis::Address SgAsmNESectionTableEntry::*, &SgAsmNESectionTableEntry::p_virtualSize>;
9162};
9172template <> struct node_from_variant_t<246> { using type = SgAsmNESectionTableEntry; };
9173
9174// Class: AsmNEStringTable
9176 using node = SgAsmNEStringTable;
9177 using base = SgAsmGenericSection;
9178 static constexpr char const * const name{"AsmNEStringTable"};
9179 static constexpr unsigned long variant{247};
9180 static constexpr bool concrete{true};
9181 using subclasses_t = mp::List<>;
9182 using fields_t = mp::List<>;
9183};
9184template <> struct node_from_variant_t<247> { using type = SgAsmNEStringTable; };
9185
9186// Class: AsmNode
9187template <> struct describe_node_t<SgAsmNode> {
9188 using node = SgAsmNode;
9189 using base = SgNode;
9190 static constexpr char const * const name{"AsmNode"};
9191 static constexpr unsigned long variant{248};
9192 static constexpr bool concrete{false};
9194 using fields_t = mp::List<>;
9195};
9196template <> struct node_from_variant_t<248> { using type = SgAsmNode; };
9197
9198// Class: AsmOp
9199template <> struct describe_field_t<SgAsmOp,SgAsmOp::asm_operand_constraint_enum,&SgAsmOp::p_constraint> {
9200 using parent = SgAsmOp;
9202 static constexpr size_t position{0};
9203 static constexpr char const * const name{"constraint"};
9204 static constexpr char const * const typestr{"SgAsmOp::asm_operand_constraint_enum"};
9205 static constexpr bool traverse{false};
9206 static constexpr auto mbr_ptr{&SgAsmOp::p_constraint};
9207 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9208 using bind = Desc<SgAsmOp, SgAsmOp::asm_operand_constraint_enum SgAsmOp::*, &SgAsmOp::p_constraint>;
9209};
9210template <> struct describe_field_t<SgAsmOp,SgAsmOp::asm_operand_modifier_enum,&SgAsmOp::p_modifiers> {
9211 using parent = SgAsmOp;
9213 static constexpr size_t position{1};
9214 static constexpr char const * const name{"modifiers"};
9215 static constexpr char const * const typestr{"SgAsmOp::asm_operand_modifier_enum"};
9216 static constexpr bool traverse{false};
9217 static constexpr auto mbr_ptr{&SgAsmOp::p_modifiers};
9218 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9219 using bind = Desc<SgAsmOp, SgAsmOp::asm_operand_modifier_enum SgAsmOp::*, &SgAsmOp::p_modifiers>;
9220};
9221template <> struct describe_field_t<SgAsmOp,SgExpression*,&SgAsmOp::p_expression> {
9222 using parent = SgAsmOp;
9223 using field_type = SgExpression*;
9224 static constexpr size_t position{2};
9225 static constexpr char const * const name{"expression"};
9226 static constexpr char const * const typestr{"SgExpression*"};
9227 static constexpr bool traverse{true};
9228 static constexpr auto mbr_ptr{&SgAsmOp::p_expression};
9229 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9230 using bind = Desc<SgAsmOp, SgExpression* SgAsmOp::*, &SgAsmOp::p_expression>;
9231};
9232template <> struct describe_field_t<SgAsmOp,bool,&SgAsmOp::p_recordRawAsmOperandDescriptions> {
9233 using parent = SgAsmOp;
9234 using field_type = bool;
9235 static constexpr size_t position{3};
9236 static constexpr char const * const name{"recordRawAsmOperandDescriptions"};
9237 static constexpr char const * const typestr{"bool"};
9238 static constexpr bool traverse{false};
9239 static constexpr auto mbr_ptr{&SgAsmOp::p_recordRawAsmOperandDescriptions};
9240 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9241 using bind = Desc<SgAsmOp, bool SgAsmOp::*, &SgAsmOp::p_recordRawAsmOperandDescriptions>;
9242};
9243template <> struct describe_field_t<SgAsmOp,bool,&SgAsmOp::p_isOutputOperand> {
9244 using parent = SgAsmOp;
9245 using field_type = bool;
9246 static constexpr size_t position{4};
9247 static constexpr char const * const name{"isOutputOperand"};
9248 static constexpr char const * const typestr{"bool"};
9249 static constexpr bool traverse{false};
9250 static constexpr auto mbr_ptr{&SgAsmOp::p_isOutputOperand};
9251 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9252 using bind = Desc<SgAsmOp, bool SgAsmOp::*, &SgAsmOp::p_isOutputOperand>;
9253};
9254template <> struct describe_field_t<SgAsmOp,std::string,&SgAsmOp::p_constraintString> {
9255 using parent = SgAsmOp;
9256 using field_type = std::string;
9257 static constexpr size_t position{5};
9258 static constexpr char const * const name{"constraintString"};
9259 static constexpr char const * const typestr{"std::string"};
9260 static constexpr bool traverse{false};
9261 static constexpr auto mbr_ptr{&SgAsmOp::p_constraintString};
9262 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9263 using bind = Desc<SgAsmOp, std::string SgAsmOp::*, &SgAsmOp::p_constraintString>;
9264};
9265template <> struct describe_field_t<SgAsmOp,std::string,&SgAsmOp::p_name> {
9266 using parent = SgAsmOp;
9267 using field_type = std::string;
9268 static constexpr size_t position{6};
9269 static constexpr char const * const name{"name"};
9270 static constexpr char const * const typestr{"std::string"};
9271 static constexpr bool traverse{false};
9272 static constexpr auto mbr_ptr{&SgAsmOp::p_name};
9273 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9274 using bind = Desc<SgAsmOp, std::string SgAsmOp::*, &SgAsmOp::p_name>;
9275};
9285template <> struct node_from_variant_t<249> { using type = SgAsmOp; };
9286
9287// Class: AsmOperandList
9288template <> struct describe_field_t<SgAsmOperandList,SgAsmExpressionPtrList,&SgAsmOperandList::p_operands> {
9289 using parent = SgAsmOperandList;
9290 using field_type = SgAsmExpressionPtrList;
9291 static constexpr size_t position{0};
9292 static constexpr char const * const name{"operands"};
9293 static constexpr char const * const typestr{"SgAsmExpressionPtrList"};
9294 static constexpr bool traverse{true};
9295 static constexpr auto mbr_ptr{&SgAsmOperandList::p_operands};
9296 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9297 using bind = Desc<SgAsmOperandList, SgAsmExpressionPtrList SgAsmOperandList::*, &SgAsmOperandList::p_operands>;
9298};
9300 using node = SgAsmOperandList;
9301 using base = SgAsmNode;
9302 static constexpr char const * const name{"AsmOperandList"};
9303 static constexpr unsigned long variant{250};
9304 static constexpr bool concrete{true};
9305 using subclasses_t = mp::List<>;
9307};
9308template <> struct node_from_variant_t<250> { using type = SgAsmOperandList; };
9309
9310// Class: AsmPEExportDirectory
9311template <> struct describe_field_t<SgAsmPEExportDirectory,unsigned,&SgAsmPEExportDirectory::p_res1> {
9313 using field_type = unsigned;
9314 static constexpr size_t position{0};
9315 static constexpr char const * const name{"res1"};
9316 static constexpr char const * const typestr{"unsigned"};
9317 static constexpr bool traverse{false};
9318 static constexpr auto mbr_ptr{&SgAsmPEExportDirectory::p_res1};
9319 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9320 using bind = Desc<SgAsmPEExportDirectory, unsigned SgAsmPEExportDirectory::*, &SgAsmPEExportDirectory::p_res1>;
9321};
9322template <> struct describe_field_t<SgAsmPEExportDirectory,time_t,&SgAsmPEExportDirectory::p_timestamp> {
9324 using field_type = time_t;
9325 static constexpr size_t position{1};
9326 static constexpr char const * const name{"timestamp"};
9327 static constexpr char const * const typestr{"time_t"};
9328 static constexpr bool traverse{false};
9329 static constexpr auto mbr_ptr{&SgAsmPEExportDirectory::p_timestamp};
9330 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9331 using bind = Desc<SgAsmPEExportDirectory, time_t SgAsmPEExportDirectory::*, &SgAsmPEExportDirectory::p_timestamp>;
9332};
9333template <> struct describe_field_t<SgAsmPEExportDirectory,unsigned,&SgAsmPEExportDirectory::p_vmajor> {
9335 using field_type = unsigned;
9336 static constexpr size_t position{2};
9337 static constexpr char const * const name{"vmajor"};
9338 static constexpr char const * const typestr{"unsigned"};
9339 static constexpr bool traverse{false};
9340 static constexpr auto mbr_ptr{&SgAsmPEExportDirectory::p_vmajor};
9341 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9342 using bind = Desc<SgAsmPEExportDirectory, unsigned SgAsmPEExportDirectory::*, &SgAsmPEExportDirectory::p_vmajor>;
9343};
9344template <> struct describe_field_t<SgAsmPEExportDirectory,unsigned,&SgAsmPEExportDirectory::p_vminor> {
9346 using field_type = unsigned;
9347 static constexpr size_t position{3};
9348 static constexpr char const * const name{"vminor"};
9349 static constexpr char const * const typestr{"unsigned"};
9350 static constexpr bool traverse{false};
9351 static constexpr auto mbr_ptr{&SgAsmPEExportDirectory::p_vminor};
9352 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9353 using bind = Desc<SgAsmPEExportDirectory, unsigned SgAsmPEExportDirectory::*, &SgAsmPEExportDirectory::p_vminor>;
9354};
9355template <> struct describe_field_t<SgAsmPEExportDirectory,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmPEExportDirectory::p_name_rva> {
9358 static constexpr size_t position{4};
9359 static constexpr char const * const name{"name_rva"};
9360 static constexpr char const * const typestr{"Rose::BinaryAnalysis::RelativeVirtualAddress"};
9361 static constexpr bool traverse{false};
9362 static constexpr auto mbr_ptr{&SgAsmPEExportDirectory::p_name_rva};
9363 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9364 using bind = Desc<SgAsmPEExportDirectory, Rose::BinaryAnalysis::RelativeVirtualAddress SgAsmPEExportDirectory::*, &SgAsmPEExportDirectory::p_name_rva>;
9365};
9366template <> struct describe_field_t<SgAsmPEExportDirectory,unsigned,&SgAsmPEExportDirectory::p_ord_base> {
9368 using field_type = unsigned;
9369 static constexpr size_t position{5};
9370 static constexpr char const * const name{"ord_base"};
9371 static constexpr char const * const typestr{"unsigned"};
9372 static constexpr bool traverse{false};
9373 static constexpr auto mbr_ptr{&SgAsmPEExportDirectory::p_ord_base};
9374 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9375 using bind = Desc<SgAsmPEExportDirectory, unsigned SgAsmPEExportDirectory::*, &SgAsmPEExportDirectory::p_ord_base>;
9376};
9377template <> struct describe_field_t<SgAsmPEExportDirectory,size_t,&SgAsmPEExportDirectory::p_expaddr_n> {
9379 using field_type = size_t;
9380 static constexpr size_t position{6};
9381 static constexpr char const * const name{"expaddr_n"};
9382 static constexpr char const * const typestr{"size_t"};
9383 static constexpr bool traverse{false};
9384 static constexpr auto mbr_ptr{&SgAsmPEExportDirectory::p_expaddr_n};
9385 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9386 using bind = Desc<SgAsmPEExportDirectory, size_t SgAsmPEExportDirectory::*, &SgAsmPEExportDirectory::p_expaddr_n>;
9387};
9388template <> struct describe_field_t<SgAsmPEExportDirectory,size_t,&SgAsmPEExportDirectory::p_nameptr_n> {
9390 using field_type = size_t;
9391 static constexpr size_t position{7};
9392 static constexpr char const * const name{"nameptr_n"};
9393 static constexpr char const * const typestr{"size_t"};
9394 static constexpr bool traverse{false};
9395 static constexpr auto mbr_ptr{&SgAsmPEExportDirectory::p_nameptr_n};
9396 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9397 using bind = Desc<SgAsmPEExportDirectory, size_t SgAsmPEExportDirectory::*, &SgAsmPEExportDirectory::p_nameptr_n>;
9398};
9399template <> struct describe_field_t<SgAsmPEExportDirectory,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmPEExportDirectory::p_expaddr_rva> {
9402 static constexpr size_t position{8};
9403 static constexpr char const * const name{"expaddr_rva"};
9404 static constexpr char const * const typestr{"Rose::BinaryAnalysis::RelativeVirtualAddress"};
9405 static constexpr bool traverse{false};
9406 static constexpr auto mbr_ptr{&SgAsmPEExportDirectory::p_expaddr_rva};
9407 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9408 using bind = Desc<SgAsmPEExportDirectory, Rose::BinaryAnalysis::RelativeVirtualAddress SgAsmPEExportDirectory::*, &SgAsmPEExportDirectory::p_expaddr_rva>;
9409};
9410template <> struct describe_field_t<SgAsmPEExportDirectory,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmPEExportDirectory::p_nameptr_rva> {
9413 static constexpr size_t position{9};
9414 static constexpr char const * const name{"nameptr_rva"};
9415 static constexpr char const * const typestr{"Rose::BinaryAnalysis::RelativeVirtualAddress"};
9416 static constexpr bool traverse{false};
9417 static constexpr auto mbr_ptr{&SgAsmPEExportDirectory::p_nameptr_rva};
9418 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9419 using bind = Desc<SgAsmPEExportDirectory, Rose::BinaryAnalysis::RelativeVirtualAddress SgAsmPEExportDirectory::*, &SgAsmPEExportDirectory::p_nameptr_rva>;
9420};
9421template <> struct describe_field_t<SgAsmPEExportDirectory,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmPEExportDirectory::p_ordinals_rva> {
9424 static constexpr size_t position{10};
9425 static constexpr char const * const name{"ordinals_rva"};
9426 static constexpr char const * const typestr{"Rose::BinaryAnalysis::RelativeVirtualAddress"};
9427 static constexpr bool traverse{false};
9428 static constexpr auto mbr_ptr{&SgAsmPEExportDirectory::p_ordinals_rva};
9429 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9430 using bind = Desc<SgAsmPEExportDirectory, Rose::BinaryAnalysis::RelativeVirtualAddress SgAsmPEExportDirectory::*, &SgAsmPEExportDirectory::p_ordinals_rva>;
9431};
9432template <> struct describe_field_t<SgAsmPEExportDirectory,SgAsmGenericString*,&SgAsmPEExportDirectory::p_name> {
9435 static constexpr size_t position{11};
9436 static constexpr char const * const name{"name"};
9437 static constexpr char const * const typestr{"SgAsmGenericString*"};
9438 static constexpr bool traverse{true};
9439 static constexpr auto mbr_ptr{&SgAsmPEExportDirectory::p_name};
9440 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9441 using bind = Desc<SgAsmPEExportDirectory, SgAsmGenericString* SgAsmPEExportDirectory::*, &SgAsmPEExportDirectory::p_name>;
9442};
9446 static constexpr char const * const name{"AsmPEExportDirectory"};
9447 static constexpr unsigned long variant{251};
9448 static constexpr bool concrete{true};
9449 using subclasses_t = mp::List<>;
9451};
9452template <> struct node_from_variant_t<251> { using type = SgAsmPEExportDirectory; };
9453
9454// Class: AsmPEExportEntry
9455template <> struct describe_field_t<SgAsmPEExportEntry,SgAsmGenericString*,&SgAsmPEExportEntry::p_name> {
9456 using parent = SgAsmPEExportEntry;
9458 static constexpr size_t position{0};
9459 static constexpr char const * const name{"name"};
9460 static constexpr char const * const typestr{"SgAsmGenericString*"};
9461 static constexpr bool traverse{true};
9462 static constexpr auto mbr_ptr{&SgAsmPEExportEntry::p_name};
9463 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9464 using bind = Desc<SgAsmPEExportEntry, SgAsmGenericString* SgAsmPEExportEntry::*, &SgAsmPEExportEntry::p_name>;
9465};
9466template <> struct describe_field_t<SgAsmPEExportEntry,unsigned,&SgAsmPEExportEntry::p_ordinal> {
9467 using parent = SgAsmPEExportEntry;
9468 using field_type = unsigned;
9469 static constexpr size_t position{1};
9470 static constexpr char const * const name{"ordinal"};
9471 static constexpr char const * const typestr{"unsigned"};
9472 static constexpr bool traverse{false};
9473 static constexpr auto mbr_ptr{&SgAsmPEExportEntry::p_ordinal};
9474 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9475 using bind = Desc<SgAsmPEExportEntry, unsigned SgAsmPEExportEntry::*, &SgAsmPEExportEntry::p_ordinal>;
9476};
9477template <> struct describe_field_t<SgAsmPEExportEntry,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmPEExportEntry::p_exportRva> {
9478 using parent = SgAsmPEExportEntry;
9480 static constexpr size_t position{2};
9481 static constexpr char const * const name{"exportRva"};
9482 static constexpr char const * const typestr{"Rose::BinaryAnalysis::RelativeVirtualAddress"};
9483 static constexpr bool traverse{false};
9484 static constexpr auto mbr_ptr{&SgAsmPEExportEntry::p_exportRva};
9485 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9486 using bind = Desc<SgAsmPEExportEntry, Rose::BinaryAnalysis::RelativeVirtualAddress SgAsmPEExportEntry::*, &SgAsmPEExportEntry::p_exportRva>;
9487};
9488template <> struct describe_field_t<SgAsmPEExportEntry,SgAsmGenericString*,&SgAsmPEExportEntry::p_forwarder> {
9489 using parent = SgAsmPEExportEntry;
9491 static constexpr size_t position{3};
9492 static constexpr char const * const name{"forwarder"};
9493 static constexpr char const * const typestr{"SgAsmGenericString*"};
9494 static constexpr bool traverse{true};
9495 static constexpr auto mbr_ptr{&SgAsmPEExportEntry::p_forwarder};
9496 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9497 using bind = Desc<SgAsmPEExportEntry, SgAsmGenericString* SgAsmPEExportEntry::*, &SgAsmPEExportEntry::p_forwarder>;
9498};
9508template <> struct node_from_variant_t<252> { using type = SgAsmPEExportEntry; };
9509
9510// Class: AsmPEExportEntryList
9511template <> struct describe_field_t<SgAsmPEExportEntryList,SgAsmPEExportEntryPtrList,&SgAsmPEExportEntryList::p_exports> {
9513 using field_type = SgAsmPEExportEntryPtrList;
9514 static constexpr size_t position{0};
9515 static constexpr char const * const name{"exports"};
9516 static constexpr char const * const typestr{"SgAsmPEExportEntryPtrList"};
9517 static constexpr bool traverse{true};
9518 static constexpr auto mbr_ptr{&SgAsmPEExportEntryList::p_exports};
9519 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9520 using bind = Desc<SgAsmPEExportEntryList, SgAsmPEExportEntryPtrList SgAsmPEExportEntryList::*, &SgAsmPEExportEntryList::p_exports>;
9521};
9525 static constexpr char const * const name{"AsmPEExportEntryList"};
9526 static constexpr unsigned long variant{253};
9527 static constexpr bool concrete{true};
9528 using subclasses_t = mp::List<>;
9530};
9531template <> struct node_from_variant_t<253> { using type = SgAsmPEExportEntryList; };
9532
9533// Class: AsmPEExportSection
9534template <> struct describe_field_t<SgAsmPEExportSection,SgAsmPEExportDirectory*,&SgAsmPEExportSection::p_exportDirectory> {
9537 static constexpr size_t position{0};
9538 static constexpr char const * const name{"exportDirectory"};
9539 static constexpr char const * const typestr{"SgAsmPEExportDirectory*"};
9540 static constexpr bool traverse{true};
9541 static constexpr auto mbr_ptr{&SgAsmPEExportSection::p_exportDirectory};
9542 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9543 using bind = Desc<SgAsmPEExportSection, SgAsmPEExportDirectory* SgAsmPEExportSection::*, &SgAsmPEExportSection::p_exportDirectory>;
9544};
9545template <> struct describe_field_t<SgAsmPEExportSection,SgAsmPEExportEntryList*,&SgAsmPEExportSection::p_exports> {
9548 static constexpr size_t position{1};
9549 static constexpr char const * const name{"exports"};
9550 static constexpr char const * const typestr{"SgAsmPEExportEntryList*"};
9551 static constexpr bool traverse{true};
9552 static constexpr auto mbr_ptr{&SgAsmPEExportSection::p_exports};
9553 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9554 using bind = Desc<SgAsmPEExportSection, SgAsmPEExportEntryList* SgAsmPEExportSection::*, &SgAsmPEExportSection::p_exports>;
9555};
9557 using node = SgAsmPEExportSection;
9558 using base = SgAsmPESection;
9559 static constexpr char const * const name{"AsmPEExportSection"};
9560 static constexpr unsigned long variant{254};
9561 static constexpr bool concrete{true};
9562 using subclasses_t = mp::List<>;
9564};
9565template <> struct node_from_variant_t<254> { using type = SgAsmPEExportSection; };
9566
9567// Class: AsmPEFileHeader
9568template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_cpu_type> {
9569 using parent = SgAsmPEFileHeader;
9570 using field_type = unsigned;
9571 static constexpr size_t position{0};
9572 static constexpr char const * const name{"e_cpu_type"};
9573 static constexpr char const * const typestr{"unsigned"};
9574 static constexpr bool traverse{false};
9575 static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_cpu_type};
9576 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9577 using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_cpu_type>;
9578};
9579template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_nsections> {
9580 using parent = SgAsmPEFileHeader;
9581 using field_type = unsigned;
9582 static constexpr size_t position{1};
9583 static constexpr char const * const name{"e_nsections"};
9584 static constexpr char const * const typestr{"unsigned"};
9585 static constexpr bool traverse{false};
9586 static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_nsections};
9587 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9588 using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_nsections>;
9589};
9590template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_time> {
9591 using parent = SgAsmPEFileHeader;
9592 using field_type = unsigned;
9593 static constexpr size_t position{2};
9594 static constexpr char const * const name{"e_time"};
9595 static constexpr char const * const typestr{"unsigned"};
9596 static constexpr bool traverse{false};
9597 static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_time};
9598 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9599 using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_time>;
9600};
9601template <> struct describe_field_t<SgAsmPEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmPEFileHeader::p_e_coff_symtab> {
9602 using parent = SgAsmPEFileHeader;
9603 using field_type = Rose::BinaryAnalysis::Address;
9604 static constexpr size_t position{3};
9605 static constexpr char const * const name{"e_coff_symtab"};
9606 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
9607 static constexpr bool traverse{false};
9608 static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_coff_symtab};
9609 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9610 using bind = Desc<SgAsmPEFileHeader, Rose::BinaryAnalysis::Address SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_coff_symtab>;
9611};
9612template <> struct describe_field_t<SgAsmPEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmPEFileHeader::p_e_nt_hdr_size> {
9613 using parent = SgAsmPEFileHeader;
9614 using field_type = Rose::BinaryAnalysis::Address;
9615 static constexpr size_t position{4};
9616 static constexpr char const * const name{"e_nt_hdr_size"};
9617 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
9618 static constexpr bool traverse{false};
9619 static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_nt_hdr_size};
9620 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9621 using bind = Desc<SgAsmPEFileHeader, Rose::BinaryAnalysis::Address SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_nt_hdr_size>;
9622};
9623template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_coff_nsyms> {
9624 using parent = SgAsmPEFileHeader;
9625 using field_type = unsigned;
9626 static constexpr size_t position{5};
9627 static constexpr char const * const name{"e_coff_nsyms"};
9628 static constexpr char const * const typestr{"unsigned"};
9629 static constexpr bool traverse{false};
9630 static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_coff_nsyms};
9631 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9632 using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_coff_nsyms>;
9633};
9634template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_flags> {
9635 using parent = SgAsmPEFileHeader;
9636 using field_type = unsigned;
9637 static constexpr size_t position{6};
9638 static constexpr char const * const name{"e_flags"};
9639 static constexpr char const * const typestr{"unsigned"};
9640 static constexpr bool traverse{false};
9641 static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_flags};
9642 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9643 using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_flags>;
9644};
9645template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_opt_magic> {
9646 using parent = SgAsmPEFileHeader;
9647 using field_type = unsigned;
9648 static constexpr size_t position{7};
9649 static constexpr char const * const name{"e_opt_magic"};
9650 static constexpr char const * const typestr{"unsigned"};
9651 static constexpr bool traverse{false};
9652 static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_opt_magic};
9653 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9654 using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_opt_magic>;
9655};
9656template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_lmajor> {
9657 using parent = SgAsmPEFileHeader;
9658 using field_type = unsigned;
9659 static constexpr size_t position{8};
9660 static constexpr char const * const name{"e_lmajor"};
9661 static constexpr char const * const typestr{"unsigned"};
9662 static constexpr bool traverse{false};
9663 static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_lmajor};
9664 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9665 using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_lmajor>;
9666};
9667template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_lminor> {
9668 using parent = SgAsmPEFileHeader;
9669 using field_type = unsigned;
9670 static constexpr size_t position{9};
9671 static constexpr char const * const name{"e_lminor"};
9672 static constexpr char const * const typestr{"unsigned"};
9673 static constexpr bool traverse{false};
9674 static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_lminor};
9675 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9676 using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_lminor>;
9677};
9678template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_code_size> {
9679 using parent = SgAsmPEFileHeader;
9680 using field_type = unsigned;
9681 static constexpr size_t position{10};
9682 static constexpr char const * const name{"e_code_size"};
9683 static constexpr char const * const typestr{"unsigned"};
9684 static constexpr bool traverse{false};
9685 static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_code_size};
9686 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9687 using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_code_size>;
9688};
9689template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_data_size> {
9690 using parent = SgAsmPEFileHeader;
9691 using field_type = unsigned;
9692 static constexpr size_t position{11};
9693 static constexpr char const * const name{"e_data_size"};
9694 static constexpr char const * const typestr{"unsigned"};
9695 static constexpr bool traverse{false};
9696 static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_data_size};
9697 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9698 using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_data_size>;
9699};
9700template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_bss_size> {
9701 using parent = SgAsmPEFileHeader;
9702 using field_type = unsigned;
9703 static constexpr size_t position{12};
9704 static constexpr char const * const name{"e_bss_size"};
9705 static constexpr char const * const typestr{"unsigned"};
9706 static constexpr bool traverse{false};
9707 static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_bss_size};
9708 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9709 using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_bss_size>;
9710};
9711template <> struct describe_field_t<SgAsmPEFileHeader,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmPEFileHeader::p_e_code_rva> {
9712 using parent = SgAsmPEFileHeader;
9714 static constexpr size_t position{13};
9715 static constexpr char const * const name{"e_code_rva"};
9716 static constexpr char const * const typestr{"Rose::BinaryAnalysis::RelativeVirtualAddress"};
9717 static constexpr bool traverse{false};
9718 static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_code_rva};
9719 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9720 using bind = Desc<SgAsmPEFileHeader, Rose::BinaryAnalysis::RelativeVirtualAddress SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_code_rva>;
9721};
9722template <> struct describe_field_t<SgAsmPEFileHeader,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmPEFileHeader::p_e_data_rva> {
9723 using parent = SgAsmPEFileHeader;
9725 static constexpr size_t position{14};
9726 static constexpr char const * const name{"e_data_rva"};
9727 static constexpr char const * const typestr{"Rose::BinaryAnalysis::RelativeVirtualAddress"};
9728 static constexpr bool traverse{false};
9729 static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_data_rva};
9730 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9731 using bind = Desc<SgAsmPEFileHeader, Rose::BinaryAnalysis::RelativeVirtualAddress SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_data_rva>;
9732};
9733template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_section_align> {
9734 using parent = SgAsmPEFileHeader;
9735 using field_type = unsigned;
9736 static constexpr size_t position{15};
9737 static constexpr char const * const name{"e_section_align"};
9738 static constexpr char const * const typestr{"unsigned"};
9739 static constexpr bool traverse{false};
9740 static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_section_align};
9741 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9742 using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_section_align>;
9743};
9744template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_file_align> {
9745 using parent = SgAsmPEFileHeader;
9746 using field_type = unsigned;
9747 static constexpr size_t position{16};
9748 static constexpr char const * const name{"e_file_align"};
9749 static constexpr char const * const typestr{"unsigned"};
9750 static constexpr bool traverse{false};
9751 static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_file_align};
9752 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9753 using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_file_align>;
9754};
9755template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_os_major> {
9756 using parent = SgAsmPEFileHeader;
9757 using field_type = unsigned;
9758 static constexpr size_t position{17};
9759 static constexpr char const * const name{"e_os_major"};
9760 static constexpr char const * const typestr{"unsigned"};
9761 static constexpr bool traverse{false};
9762 static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_os_major};
9763 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9764 using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_os_major>;
9765};
9766template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_os_minor> {
9767 using parent = SgAsmPEFileHeader;
9768 using field_type = unsigned;
9769 static constexpr size_t position{18};
9770 static constexpr char const * const name{"e_os_minor"};
9771 static constexpr char const * const typestr{"unsigned"};
9772 static constexpr bool traverse{false};
9773 static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_os_minor};
9774 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9775 using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_os_minor>;
9776};
9777template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_user_major> {
9778 using parent = SgAsmPEFileHeader;
9779 using field_type = unsigned;
9780 static constexpr size_t position{19};
9781 static constexpr char const * const name{"e_user_major"};
9782 static constexpr char const * const typestr{"unsigned"};
9783 static constexpr bool traverse{false};
9784 static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_user_major};
9785 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9786 using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_user_major>;
9787};
9788template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_user_minor> {
9789 using parent = SgAsmPEFileHeader;
9790 using field_type = unsigned;
9791 static constexpr size_t position{20};
9792 static constexpr char const * const name{"e_user_minor"};
9793 static constexpr char const * const typestr{"unsigned"};
9794 static constexpr bool traverse{false};
9795 static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_user_minor};
9796 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9797 using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_user_minor>;
9798};
9799template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_subsys_major> {
9800 using parent = SgAsmPEFileHeader;
9801 using field_type = unsigned;
9802 static constexpr size_t position{21};
9803 static constexpr char const * const name{"e_subsys_major"};
9804 static constexpr char const * const typestr{"unsigned"};
9805 static constexpr bool traverse{false};
9806 static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_subsys_major};
9807 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9808 using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_subsys_major>;
9809};
9810template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_subsys_minor> {
9811 using parent = SgAsmPEFileHeader;
9812 using field_type = unsigned;
9813 static constexpr size_t position{22};
9814 static constexpr char const * const name{"e_subsys_minor"};
9815 static constexpr char const * const typestr{"unsigned"};
9816 static constexpr bool traverse{false};
9817 static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_subsys_minor};
9818 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9819 using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_subsys_minor>;
9820};
9821template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_reserved9> {
9822 using parent = SgAsmPEFileHeader;
9823 using field_type = unsigned;
9824 static constexpr size_t position{23};
9825 static constexpr char const * const name{"e_reserved9"};
9826 static constexpr char const * const typestr{"unsigned"};
9827 static constexpr bool traverse{false};
9828 static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_reserved9};
9829 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9830 using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_reserved9>;
9831};
9832template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_image_size> {
9833 using parent = SgAsmPEFileHeader;
9834 using field_type = unsigned;
9835 static constexpr size_t position{24};
9836 static constexpr char const * const name{"e_image_size"};
9837 static constexpr char const * const typestr{"unsigned"};
9838 static constexpr bool traverse{false};
9839 static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_image_size};
9840 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9841 using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_image_size>;
9842};
9843template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_header_size> {
9844 using parent = SgAsmPEFileHeader;
9845 using field_type = unsigned;
9846 static constexpr size_t position{25};
9847 static constexpr char const * const name{"e_header_size"};
9848 static constexpr char const * const typestr{"unsigned"};
9849 static constexpr bool traverse{false};
9850 static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_header_size};
9851 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9852 using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_header_size>;
9853};
9854template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_file_checksum> {
9855 using parent = SgAsmPEFileHeader;
9856 using field_type = unsigned;
9857 static constexpr size_t position{26};
9858 static constexpr char const * const name{"e_file_checksum"};
9859 static constexpr char const * const typestr{"unsigned"};
9860 static constexpr bool traverse{false};
9861 static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_file_checksum};
9862 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9863 using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_file_checksum>;
9864};
9865template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_subsystem> {
9866 using parent = SgAsmPEFileHeader;
9867 using field_type = unsigned;
9868 static constexpr size_t position{27};
9869 static constexpr char const * const name{"e_subsystem"};
9870 static constexpr char const * const typestr{"unsigned"};
9871 static constexpr bool traverse{false};
9872 static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_subsystem};
9873 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9874 using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_subsystem>;
9875};
9876template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_dll_flags> {
9877 using parent = SgAsmPEFileHeader;
9878 using field_type = unsigned;
9879 static constexpr size_t position{28};
9880 static constexpr char const * const name{"e_dll_flags"};
9881 static constexpr char const * const typestr{"unsigned"};
9882 static constexpr bool traverse{false};
9883 static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_dll_flags};
9884 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9885 using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_dll_flags>;
9886};
9887template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_stack_reserve_size> {
9888 using parent = SgAsmPEFileHeader;
9889 using field_type = unsigned;
9890 static constexpr size_t position{29};
9891 static constexpr char const * const name{"e_stack_reserve_size"};
9892 static constexpr char const * const typestr{"unsigned"};
9893 static constexpr bool traverse{false};
9894 static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_stack_reserve_size};
9895 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9896 using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_stack_reserve_size>;
9897};
9898template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_stack_commit_size> {
9899 using parent = SgAsmPEFileHeader;
9900 using field_type = unsigned;
9901 static constexpr size_t position{30};
9902 static constexpr char const * const name{"e_stack_commit_size"};
9903 static constexpr char const * const typestr{"unsigned"};
9904 static constexpr bool traverse{false};
9905 static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_stack_commit_size};
9906 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9907 using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_stack_commit_size>;
9908};
9909template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_heap_reserve_size> {
9910 using parent = SgAsmPEFileHeader;
9911 using field_type = unsigned;
9912 static constexpr size_t position{31};
9913 static constexpr char const * const name{"e_heap_reserve_size"};
9914 static constexpr char const * const typestr{"unsigned"};
9915 static constexpr bool traverse{false};
9916 static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_heap_reserve_size};
9917 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9918 using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_heap_reserve_size>;
9919};
9920template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_heap_commit_size> {
9921 using parent = SgAsmPEFileHeader;
9922 using field_type = unsigned;
9923 static constexpr size_t position{32};
9924 static constexpr char const * const name{"e_heap_commit_size"};
9925 static constexpr char const * const typestr{"unsigned"};
9926 static constexpr bool traverse{false};
9927 static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_heap_commit_size};
9928 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9929 using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_heap_commit_size>;
9930};
9931template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_loader_flags> {
9932 using parent = SgAsmPEFileHeader;
9933 using field_type = unsigned;
9934 static constexpr size_t position{33};
9935 static constexpr char const * const name{"e_loader_flags"};
9936 static constexpr char const * const typestr{"unsigned"};
9937 static constexpr bool traverse{false};
9938 static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_loader_flags};
9939 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9940 using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_loader_flags>;
9941};
9942template <> struct describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_num_rvasize_pairs> {
9943 using parent = SgAsmPEFileHeader;
9944 using field_type = unsigned;
9945 static constexpr size_t position{34};
9946 static constexpr char const * const name{"e_num_rvasize_pairs"};
9947 static constexpr char const * const typestr{"unsigned"};
9948 static constexpr bool traverse{false};
9949 static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_e_num_rvasize_pairs};
9950 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9951 using bind = Desc<SgAsmPEFileHeader, unsigned SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_e_num_rvasize_pairs>;
9952};
9953template <> struct describe_field_t<SgAsmPEFileHeader,SgAsmPERVASizePairList*,&SgAsmPEFileHeader::p_rvaSizePairs> {
9954 using parent = SgAsmPEFileHeader;
9956 static constexpr size_t position{35};
9957 static constexpr char const * const name{"rvaSizePairs"};
9958 static constexpr char const * const typestr{"SgAsmPERVASizePairList*"};
9959 static constexpr bool traverse{true};
9960 static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_rvaSizePairs};
9961 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9962 using bind = Desc<SgAsmPEFileHeader, SgAsmPERVASizePairList* SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_rvaSizePairs>;
9963};
9964template <> struct describe_field_t<SgAsmPEFileHeader,SgAsmPESectionTable*,&SgAsmPEFileHeader::p_sectionTable> {
9965 using parent = SgAsmPEFileHeader;
9967 static constexpr size_t position{36};
9968 static constexpr char const * const name{"sectionTable"};
9969 static constexpr char const * const typestr{"SgAsmPESectionTable*"};
9970 static constexpr bool traverse{false};
9971 static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_sectionTable};
9972 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9973 using bind = Desc<SgAsmPEFileHeader, SgAsmPESectionTable* SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_sectionTable>;
9974};
9975template <> struct describe_field_t<SgAsmPEFileHeader,SgAsmCoffSymbolTable*,&SgAsmPEFileHeader::p_coffSymbolTable> {
9976 using parent = SgAsmPEFileHeader;
9978 static constexpr size_t position{37};
9979 static constexpr char const * const name{"coffSymbolTable"};
9980 static constexpr char const * const typestr{"SgAsmCoffSymbolTable*"};
9981 static constexpr bool traverse{false};
9982 static constexpr auto mbr_ptr{&SgAsmPEFileHeader::p_coffSymbolTable};
9983 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
9984 using bind = Desc<SgAsmPEFileHeader, SgAsmCoffSymbolTable* SgAsmPEFileHeader::*, &SgAsmPEFileHeader::p_coffSymbolTable>;
9985};
9987 using node = SgAsmPEFileHeader;
9988 using base = SgAsmGenericHeader;
9989 static constexpr char const * const name{"AsmPEFileHeader"};
9990 static constexpr unsigned long variant{255};
9991 static constexpr bool concrete{true};
9992 using subclasses_t = mp::List<>;
9993 using fields_t = mp::List<describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_cpu_type>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_nsections>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_time>, describe_field_t<SgAsmPEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmPEFileHeader::p_e_coff_symtab>, describe_field_t<SgAsmPEFileHeader,Rose::BinaryAnalysis::Address,&SgAsmPEFileHeader::p_e_nt_hdr_size>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_coff_nsyms>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_flags>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_opt_magic>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_lmajor>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_lminor>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_code_size>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_data_size>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_bss_size>, describe_field_t<SgAsmPEFileHeader,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmPEFileHeader::p_e_code_rva>, describe_field_t<SgAsmPEFileHeader,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmPEFileHeader::p_e_data_rva>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_section_align>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_file_align>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_os_major>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_os_minor>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_user_major>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_user_minor>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_subsys_major>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_subsys_minor>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_reserved9>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_image_size>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_header_size>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_file_checksum>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_subsystem>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_dll_flags>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_stack_reserve_size>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_stack_commit_size>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_heap_reserve_size>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_heap_commit_size>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_loader_flags>, describe_field_t<SgAsmPEFileHeader,unsigned,&SgAsmPEFileHeader::p_e_num_rvasize_pairs>, describe_field_t<SgAsmPEFileHeader,SgAsmPERVASizePairList*,&SgAsmPEFileHeader::p_rvaSizePairs>, describe_field_t<SgAsmPEFileHeader,SgAsmPESectionTable*,&SgAsmPEFileHeader::p_sectionTable>, describe_field_t<SgAsmPEFileHeader,SgAsmCoffSymbolTable*,&SgAsmPEFileHeader::p_coffSymbolTable>>;
9994};
9995template <> struct node_from_variant_t<255> { using type = SgAsmPEFileHeader; };
9996
9997// Class: AsmPEImportDirectory
9998template <> struct describe_field_t<SgAsmPEImportDirectory,SgAsmGenericString*,&SgAsmPEImportDirectory::p_dllName> {
10001 static constexpr size_t position{0};
10002 static constexpr char const * const name{"dllName"};
10003 static constexpr char const * const typestr{"SgAsmGenericString*"};
10004 static constexpr bool traverse{true};
10005 static constexpr auto mbr_ptr{&SgAsmPEImportDirectory::p_dllName};
10006 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10007 using bind = Desc<SgAsmPEImportDirectory, SgAsmGenericString* SgAsmPEImportDirectory::*, &SgAsmPEImportDirectory::p_dllName>;
10008};
10009template <> struct describe_field_t<SgAsmPEImportDirectory,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmPEImportDirectory::p_dllNameRva> {
10012 static constexpr size_t position{1};
10013 static constexpr char const * const name{"dllNameRva"};
10014 static constexpr char const * const typestr{"Rose::BinaryAnalysis::RelativeVirtualAddress"};
10015 static constexpr bool traverse{false};
10016 static constexpr auto mbr_ptr{&SgAsmPEImportDirectory::p_dllNameRva};
10017 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10018 using bind = Desc<SgAsmPEImportDirectory, Rose::BinaryAnalysis::RelativeVirtualAddress SgAsmPEImportDirectory::*, &SgAsmPEImportDirectory::p_dllNameRva>;
10019};
10020template <> struct describe_field_t<SgAsmPEImportDirectory,size_t,&SgAsmPEImportDirectory::p_dll_name_nalloc> {
10022 using field_type = size_t;
10023 static constexpr size_t position{2};
10024 static constexpr char const * const name{"dll_name_nalloc"};
10025 static constexpr char const * const typestr{"size_t"};
10026 static constexpr bool traverse{false};
10027 static constexpr auto mbr_ptr{&SgAsmPEImportDirectory::p_dll_name_nalloc};
10028 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10029 using bind = Desc<SgAsmPEImportDirectory, size_t SgAsmPEImportDirectory::*, &SgAsmPEImportDirectory::p_dll_name_nalloc>;
10030};
10031template <> struct describe_field_t<SgAsmPEImportDirectory,time_t,&SgAsmPEImportDirectory::p_time> {
10033 using field_type = time_t;
10034 static constexpr size_t position{3};
10035 static constexpr char const * const name{"time"};
10036 static constexpr char const * const typestr{"time_t"};
10037 static constexpr bool traverse{false};
10038 static constexpr auto mbr_ptr{&SgAsmPEImportDirectory::p_time};
10039 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10040 using bind = Desc<SgAsmPEImportDirectory, time_t SgAsmPEImportDirectory::*, &SgAsmPEImportDirectory::p_time>;
10041};
10042template <> struct describe_field_t<SgAsmPEImportDirectory,unsigned,&SgAsmPEImportDirectory::p_forwarder_chain> {
10044 using field_type = unsigned;
10045 static constexpr size_t position{4};
10046 static constexpr char const * const name{"forwarder_chain"};
10047 static constexpr char const * const typestr{"unsigned"};
10048 static constexpr bool traverse{false};
10049 static constexpr auto mbr_ptr{&SgAsmPEImportDirectory::p_forwarder_chain};
10050 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10051 using bind = Desc<SgAsmPEImportDirectory, unsigned SgAsmPEImportDirectory::*, &SgAsmPEImportDirectory::p_forwarder_chain>;
10052};
10053template <> struct describe_field_t<SgAsmPEImportDirectory,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmPEImportDirectory::p_ilt_rva> {
10056 static constexpr size_t position{5};
10057 static constexpr char const * const name{"ilt_rva"};
10058 static constexpr char const * const typestr{"Rose::BinaryAnalysis::RelativeVirtualAddress"};
10059 static constexpr bool traverse{false};
10060 static constexpr auto mbr_ptr{&SgAsmPEImportDirectory::p_ilt_rva};
10061 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10062 using bind = Desc<SgAsmPEImportDirectory, Rose::BinaryAnalysis::RelativeVirtualAddress SgAsmPEImportDirectory::*, &SgAsmPEImportDirectory::p_ilt_rva>;
10063};
10064template <> struct describe_field_t<SgAsmPEImportDirectory,size_t,&SgAsmPEImportDirectory::p_ilt_nalloc> {
10066 using field_type = size_t;
10067 static constexpr size_t position{6};
10068 static constexpr char const * const name{"ilt_nalloc"};
10069 static constexpr char const * const typestr{"size_t"};
10070 static constexpr bool traverse{false};
10071 static constexpr auto mbr_ptr{&SgAsmPEImportDirectory::p_ilt_nalloc};
10072 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10073 using bind = Desc<SgAsmPEImportDirectory, size_t SgAsmPEImportDirectory::*, &SgAsmPEImportDirectory::p_ilt_nalloc>;
10074};
10075template <> struct describe_field_t<SgAsmPEImportDirectory,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmPEImportDirectory::p_iat_rva> {
10078 static constexpr size_t position{7};
10079 static constexpr char const * const name{"iat_rva"};
10080 static constexpr char const * const typestr{"Rose::BinaryAnalysis::RelativeVirtualAddress"};
10081 static constexpr bool traverse{false};
10082 static constexpr auto mbr_ptr{&SgAsmPEImportDirectory::p_iat_rva};
10083 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10084 using bind = Desc<SgAsmPEImportDirectory, Rose::BinaryAnalysis::RelativeVirtualAddress SgAsmPEImportDirectory::*, &SgAsmPEImportDirectory::p_iat_rva>;
10085};
10086template <> struct describe_field_t<SgAsmPEImportDirectory,size_t,&SgAsmPEImportDirectory::p_iat_nalloc> {
10088 using field_type = size_t;
10089 static constexpr size_t position{8};
10090 static constexpr char const * const name{"iat_nalloc"};
10091 static constexpr char const * const typestr{"size_t"};
10092 static constexpr bool traverse{false};
10093 static constexpr auto mbr_ptr{&SgAsmPEImportDirectory::p_iat_nalloc};
10094 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10095 using bind = Desc<SgAsmPEImportDirectory, size_t SgAsmPEImportDirectory::*, &SgAsmPEImportDirectory::p_iat_nalloc>;
10096};
10097template <> struct describe_field_t<SgAsmPEImportDirectory,SgAsmPEImportItemList*,&SgAsmPEImportDirectory::p_imports> {
10100 static constexpr size_t position{9};
10101 static constexpr char const * const name{"imports"};
10102 static constexpr char const * const typestr{"SgAsmPEImportItemList*"};
10103 static constexpr bool traverse{true};
10104 static constexpr auto mbr_ptr{&SgAsmPEImportDirectory::p_imports};
10105 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10106 using bind = Desc<SgAsmPEImportDirectory, SgAsmPEImportItemList* SgAsmPEImportDirectory::*, &SgAsmPEImportDirectory::p_imports>;
10107};
10117template <> struct node_from_variant_t<256> { using type = SgAsmPEImportDirectory; };
10118
10119// Class: AsmPEImportDirectoryList
10120template <> struct describe_field_t<SgAsmPEImportDirectoryList,SgAsmPEImportDirectoryPtrList,&SgAsmPEImportDirectoryList::p_vector> {
10122 using field_type = SgAsmPEImportDirectoryPtrList;
10123 static constexpr size_t position{0};
10124 static constexpr char const * const name{"vector"};
10125 static constexpr char const * const typestr{"SgAsmPEImportDirectoryPtrList"};
10126 static constexpr bool traverse{true};
10127 static constexpr auto mbr_ptr{&SgAsmPEImportDirectoryList::p_vector};
10128 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10129 using bind = Desc<SgAsmPEImportDirectoryList, SgAsmPEImportDirectoryPtrList SgAsmPEImportDirectoryList::*, &SgAsmPEImportDirectoryList::p_vector>;
10130};
10134 static constexpr char const * const name{"AsmPEImportDirectoryList"};
10135 static constexpr unsigned long variant{257};
10136 static constexpr bool concrete{true};
10137 using subclasses_t = mp::List<>;
10139};
10140template <> struct node_from_variant_t<257> { using type = SgAsmPEImportDirectoryList; };
10141
10142// Class: AsmPEImportItem
10143template <> struct describe_field_t<SgAsmPEImportItem,bool,&SgAsmPEImportItem::p_by_ordinal> {
10144 using parent = SgAsmPEImportItem;
10145 using field_type = bool;
10146 static constexpr size_t position{0};
10147 static constexpr char const * const name{"by_ordinal"};
10148 static constexpr char const * const typestr{"bool"};
10149 static constexpr bool traverse{false};
10150 static constexpr auto mbr_ptr{&SgAsmPEImportItem::p_by_ordinal};
10151 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10152 using bind = Desc<SgAsmPEImportItem, bool SgAsmPEImportItem::*, &SgAsmPEImportItem::p_by_ordinal>;
10153};
10154template <> struct describe_field_t<SgAsmPEImportItem,unsigned,&SgAsmPEImportItem::p_ordinal> {
10155 using parent = SgAsmPEImportItem;
10156 using field_type = unsigned;
10157 static constexpr size_t position{1};
10158 static constexpr char const * const name{"ordinal"};
10159 static constexpr char const * const typestr{"unsigned"};
10160 static constexpr bool traverse{false};
10161 static constexpr auto mbr_ptr{&SgAsmPEImportItem::p_ordinal};
10162 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10163 using bind = Desc<SgAsmPEImportItem, unsigned SgAsmPEImportItem::*, &SgAsmPEImportItem::p_ordinal>;
10164};
10165template <> struct describe_field_t<SgAsmPEImportItem,unsigned,&SgAsmPEImportItem::p_hint> {
10166 using parent = SgAsmPEImportItem;
10167 using field_type = unsigned;
10168 static constexpr size_t position{2};
10169 static constexpr char const * const name{"hint"};
10170 static constexpr char const * const typestr{"unsigned"};
10171 static constexpr bool traverse{false};
10172 static constexpr auto mbr_ptr{&SgAsmPEImportItem::p_hint};
10173 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10174 using bind = Desc<SgAsmPEImportItem, unsigned SgAsmPEImportItem::*, &SgAsmPEImportItem::p_hint>;
10175};
10176template <> struct describe_field_t<SgAsmPEImportItem,SgAsmGenericString*,&SgAsmPEImportItem::p_name> {
10177 using parent = SgAsmPEImportItem;
10179 static constexpr size_t position{3};
10180 static constexpr char const * const name{"name"};
10181 static constexpr char const * const typestr{"SgAsmGenericString*"};
10182 static constexpr bool traverse{true};
10183 static constexpr auto mbr_ptr{&SgAsmPEImportItem::p_name};
10184 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10185 using bind = Desc<SgAsmPEImportItem, SgAsmGenericString* SgAsmPEImportItem::*, &SgAsmPEImportItem::p_name>;
10186};
10187template <> struct describe_field_t<SgAsmPEImportItem,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmPEImportItem::p_hintname_rva> {
10188 using parent = SgAsmPEImportItem;
10190 static constexpr size_t position{4};
10191 static constexpr char const * const name{"hintname_rva"};
10192 static constexpr char const * const typestr{"Rose::BinaryAnalysis::RelativeVirtualAddress"};
10193 static constexpr bool traverse{false};
10194 static constexpr auto mbr_ptr{&SgAsmPEImportItem::p_hintname_rva};
10195 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10196 using bind = Desc<SgAsmPEImportItem, Rose::BinaryAnalysis::RelativeVirtualAddress SgAsmPEImportItem::*, &SgAsmPEImportItem::p_hintname_rva>;
10197};
10198template <> struct describe_field_t<SgAsmPEImportItem,size_t,&SgAsmPEImportItem::p_hintname_nalloc> {
10199 using parent = SgAsmPEImportItem;
10200 using field_type = size_t;
10201 static constexpr size_t position{5};
10202 static constexpr char const * const name{"hintname_nalloc"};
10203 static constexpr char const * const typestr{"size_t"};
10204 static constexpr bool traverse{false};
10205 static constexpr auto mbr_ptr{&SgAsmPEImportItem::p_hintname_nalloc};
10206 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10207 using bind = Desc<SgAsmPEImportItem, size_t SgAsmPEImportItem::*, &SgAsmPEImportItem::p_hintname_nalloc>;
10208};
10209template <> struct describe_field_t<SgAsmPEImportItem,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmPEImportItem::p_bound_rva> {
10210 using parent = SgAsmPEImportItem;
10212 static constexpr size_t position{6};
10213 static constexpr char const * const name{"bound_rva"};
10214 static constexpr char const * const typestr{"Rose::BinaryAnalysis::RelativeVirtualAddress"};
10215 static constexpr bool traverse{false};
10216 static constexpr auto mbr_ptr{&SgAsmPEImportItem::p_bound_rva};
10217 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10218 using bind = Desc<SgAsmPEImportItem, Rose::BinaryAnalysis::RelativeVirtualAddress SgAsmPEImportItem::*, &SgAsmPEImportItem::p_bound_rva>;
10219};
10220template <> struct describe_field_t<SgAsmPEImportItem,bool,&SgAsmPEImportItem::p_iat_written> {
10221 using parent = SgAsmPEImportItem;
10222 using field_type = bool;
10223 static constexpr size_t position{7};
10224 static constexpr char const * const name{"iat_written"};
10225 static constexpr char const * const typestr{"bool"};
10226 static constexpr bool traverse{false};
10227 static constexpr auto mbr_ptr{&SgAsmPEImportItem::p_iat_written};
10228 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10229 using bind = Desc<SgAsmPEImportItem, bool SgAsmPEImportItem::*, &SgAsmPEImportItem::p_iat_written>;
10230};
10240template <> struct node_from_variant_t<258> { using type = SgAsmPEImportItem; };
10241
10242// Class: AsmPEImportItemList
10243template <> struct describe_field_t<SgAsmPEImportItemList,SgAsmPEImportItemPtrList,&SgAsmPEImportItemList::p_vector> {
10245 using field_type = SgAsmPEImportItemPtrList;
10246 static constexpr size_t position{0};
10247 static constexpr char const * const name{"vector"};
10248 static constexpr char const * const typestr{"SgAsmPEImportItemPtrList"};
10249 static constexpr bool traverse{true};
10250 static constexpr auto mbr_ptr{&SgAsmPEImportItemList::p_vector};
10251 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10252 using bind = Desc<SgAsmPEImportItemList, SgAsmPEImportItemPtrList SgAsmPEImportItemList::*, &SgAsmPEImportItemList::p_vector>;
10253};
10257 static constexpr char const * const name{"AsmPEImportItemList"};
10258 static constexpr unsigned long variant{259};
10259 static constexpr bool concrete{true};
10260 using subclasses_t = mp::List<>;
10262};
10263template <> struct node_from_variant_t<259> { using type = SgAsmPEImportItemList; };
10264
10265// Class: AsmPEImportSection
10266template <> struct describe_field_t<SgAsmPEImportSection,SgAsmPEImportDirectoryList*,&SgAsmPEImportSection::p_importDirectories> {
10269 static constexpr size_t position{0};
10270 static constexpr char const * const name{"importDirectories"};
10271 static constexpr char const * const typestr{"SgAsmPEImportDirectoryList*"};
10272 static constexpr bool traverse{true};
10273 static constexpr auto mbr_ptr{&SgAsmPEImportSection::p_importDirectories};
10274 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10275 using bind = Desc<SgAsmPEImportSection, SgAsmPEImportDirectoryList* SgAsmPEImportSection::*, &SgAsmPEImportSection::p_importDirectories>;
10276};
10278 using node = SgAsmPEImportSection;
10279 using base = SgAsmPESection;
10280 static constexpr char const * const name{"AsmPEImportSection"};
10281 static constexpr unsigned long variant{260};
10282 static constexpr bool concrete{true};
10283 using subclasses_t = mp::List<>;
10285};
10286template <> struct node_from_variant_t<260> { using type = SgAsmPEImportSection; };
10287
10288// Class: AsmPERVASizePair
10289template <> struct describe_field_t<SgAsmPERVASizePair,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmPERVASizePair::p_e_rva> {
10290 using parent = SgAsmPERVASizePair;
10292 static constexpr size_t position{0};
10293 static constexpr char const * const name{"e_rva"};
10294 static constexpr char const * const typestr{"Rose::BinaryAnalysis::RelativeVirtualAddress"};
10295 static constexpr bool traverse{false};
10296 static constexpr auto mbr_ptr{&SgAsmPERVASizePair::p_e_rva};
10297 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10298 using bind = Desc<SgAsmPERVASizePair, Rose::BinaryAnalysis::RelativeVirtualAddress SgAsmPERVASizePair::*, &SgAsmPERVASizePair::p_e_rva>;
10299};
10300template <> struct describe_field_t<SgAsmPERVASizePair,Rose::BinaryAnalysis::Address,&SgAsmPERVASizePair::p_e_size> {
10301 using parent = SgAsmPERVASizePair;
10302 using field_type = Rose::BinaryAnalysis::Address;
10303 static constexpr size_t position{1};
10304 static constexpr char const * const name{"e_size"};
10305 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
10306 static constexpr bool traverse{false};
10307 static constexpr auto mbr_ptr{&SgAsmPERVASizePair::p_e_size};
10308 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10309 using bind = Desc<SgAsmPERVASizePair, Rose::BinaryAnalysis::Address SgAsmPERVASizePair::*, &SgAsmPERVASizePair::p_e_size>;
10310};
10311template <> struct describe_field_t<SgAsmPERVASizePair,SgAsmGenericSection*,&SgAsmPERVASizePair::p_section> {
10312 using parent = SgAsmPERVASizePair;
10314 static constexpr size_t position{2};
10315 static constexpr char const * const name{"section"};
10316 static constexpr char const * const typestr{"SgAsmGenericSection*"};
10317 static constexpr bool traverse{false};
10318 static constexpr auto mbr_ptr{&SgAsmPERVASizePair::p_section};
10319 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10320 using bind = Desc<SgAsmPERVASizePair, SgAsmGenericSection* SgAsmPERVASizePair::*, &SgAsmPERVASizePair::p_section>;
10321};
10331template <> struct node_from_variant_t<261> { using type = SgAsmPERVASizePair; };
10332
10333// Class: AsmPERVASizePairList
10334template <> struct describe_field_t<SgAsmPERVASizePairList,SgAsmPERVASizePairPtrList,&SgAsmPERVASizePairList::p_pairs> {
10336 using field_type = SgAsmPERVASizePairPtrList;
10337 static constexpr size_t position{0};
10338 static constexpr char const * const name{"pairs"};
10339 static constexpr char const * const typestr{"SgAsmPERVASizePairPtrList"};
10340 static constexpr bool traverse{true};
10341 static constexpr auto mbr_ptr{&SgAsmPERVASizePairList::p_pairs};
10342 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10343 using bind = Desc<SgAsmPERVASizePairList, SgAsmPERVASizePairPtrList SgAsmPERVASizePairList::*, &SgAsmPERVASizePairList::p_pairs>;
10344};
10348 static constexpr char const * const name{"AsmPERVASizePairList"};
10349 static constexpr unsigned long variant{262};
10350 static constexpr bool concrete{true};
10351 using subclasses_t = mp::List<>;
10353};
10354template <> struct node_from_variant_t<262> { using type = SgAsmPERVASizePairList; };
10355
10356// Class: AsmPESection
10357template <> struct describe_field_t<SgAsmPESection,SgAsmPESectionTableEntry*,&SgAsmPESection::p_section_entry> {
10358 using parent = SgAsmPESection;
10360 static constexpr size_t position{0};
10361 static constexpr char const * const name{"section_entry"};
10362 static constexpr char const * const typestr{"SgAsmPESectionTableEntry*"};
10363 static constexpr bool traverse{true};
10364 static constexpr auto mbr_ptr{&SgAsmPESection::p_section_entry};
10365 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10366 using bind = Desc<SgAsmPESection, SgAsmPESectionTableEntry* SgAsmPESection::*, &SgAsmPESection::p_section_entry>;
10367};
10368template <> struct describe_node_t<SgAsmPESection> {
10369 using node = SgAsmPESection;
10370 using base = SgAsmGenericSection;
10371 static constexpr char const * const name{"AsmPESection"};
10372 static constexpr unsigned long variant{263};
10373 static constexpr bool concrete{true};
10376};
10377template <> struct node_from_variant_t<263> { using type = SgAsmPESection; };
10378
10379// Class: AsmPESectionTable
10381 using node = SgAsmPESectionTable;
10382 using base = SgAsmGenericSection;
10383 static constexpr char const * const name{"AsmPESectionTable"};
10384 static constexpr unsigned long variant{264};
10385 static constexpr bool concrete{true};
10386 using subclasses_t = mp::List<>;
10387 using fields_t = mp::List<>;
10388};
10389template <> struct node_from_variant_t<264> { using type = SgAsmPESectionTable; };
10390
10391// Class: AsmPESectionTableEntry
10392template <> struct describe_field_t<SgAsmPESectionTableEntry,std::string,&SgAsmPESectionTableEntry::p_name> {
10394 using field_type = std::string;
10395 static constexpr size_t position{0};
10396 static constexpr char const * const name{"name"};
10397 static constexpr char const * const typestr{"std::string"};
10398 static constexpr bool traverse{false};
10399 static constexpr auto mbr_ptr{&SgAsmPESectionTableEntry::p_name};
10400 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10401 using bind = Desc<SgAsmPESectionTableEntry, std::string SgAsmPESectionTableEntry::*, &SgAsmPESectionTableEntry::p_name>;
10402};
10403template <> struct describe_field_t<SgAsmPESectionTableEntry,Rose::BinaryAnalysis::Address,&SgAsmPESectionTableEntry::p_virtual_size> {
10405 using field_type = Rose::BinaryAnalysis::Address;
10406 static constexpr size_t position{1};
10407 static constexpr char const * const name{"virtual_size"};
10408 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
10409 static constexpr bool traverse{false};
10410 static constexpr auto mbr_ptr{&SgAsmPESectionTableEntry::p_virtual_size};
10411 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10412 using bind = Desc<SgAsmPESectionTableEntry, Rose::BinaryAnalysis::Address SgAsmPESectionTableEntry::*, &SgAsmPESectionTableEntry::p_virtual_size>;
10413};
10414template <> struct describe_field_t<SgAsmPESectionTableEntry,Rose::BinaryAnalysis::Address,&SgAsmPESectionTableEntry::p_rva> {
10416 using field_type = Rose::BinaryAnalysis::Address;
10417 static constexpr size_t position{2};
10418 static constexpr char const * const name{"rva"};
10419 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
10420 static constexpr bool traverse{false};
10421 static constexpr auto mbr_ptr{&SgAsmPESectionTableEntry::p_rva};
10422 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10423 using bind = Desc<SgAsmPESectionTableEntry, Rose::BinaryAnalysis::Address SgAsmPESectionTableEntry::*, &SgAsmPESectionTableEntry::p_rva>;
10424};
10425template <> struct describe_field_t<SgAsmPESectionTableEntry,Rose::BinaryAnalysis::Address,&SgAsmPESectionTableEntry::p_physical_size> {
10427 using field_type = Rose::BinaryAnalysis::Address;
10428 static constexpr size_t position{3};
10429 static constexpr char const * const name{"physical_size"};
10430 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
10431 static constexpr bool traverse{false};
10432 static constexpr auto mbr_ptr{&SgAsmPESectionTableEntry::p_physical_size};
10433 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10434 using bind = Desc<SgAsmPESectionTableEntry, Rose::BinaryAnalysis::Address SgAsmPESectionTableEntry::*, &SgAsmPESectionTableEntry::p_physical_size>;
10435};
10436template <> struct describe_field_t<SgAsmPESectionTableEntry,Rose::BinaryAnalysis::Address,&SgAsmPESectionTableEntry::p_physical_offset> {
10438 using field_type = Rose::BinaryAnalysis::Address;
10439 static constexpr size_t position{4};
10440 static constexpr char const * const name{"physical_offset"};
10441 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
10442 static constexpr bool traverse{false};
10443 static constexpr auto mbr_ptr{&SgAsmPESectionTableEntry::p_physical_offset};
10444 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10445 using bind = Desc<SgAsmPESectionTableEntry, Rose::BinaryAnalysis::Address SgAsmPESectionTableEntry::*, &SgAsmPESectionTableEntry::p_physical_offset>;
10446};
10447template <> struct describe_field_t<SgAsmPESectionTableEntry,unsigned,&SgAsmPESectionTableEntry::p_coff_line_nums> {
10449 using field_type = unsigned;
10450 static constexpr size_t position{5};
10451 static constexpr char const * const name{"coff_line_nums"};
10452 static constexpr char const * const typestr{"unsigned"};
10453 static constexpr bool traverse{false};
10454 static constexpr auto mbr_ptr{&SgAsmPESectionTableEntry::p_coff_line_nums};
10455 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10456 using bind = Desc<SgAsmPESectionTableEntry, unsigned SgAsmPESectionTableEntry::*, &SgAsmPESectionTableEntry::p_coff_line_nums>;
10457};
10458template <> struct describe_field_t<SgAsmPESectionTableEntry,unsigned,&SgAsmPESectionTableEntry::p_n_relocs> {
10460 using field_type = unsigned;
10461 static constexpr size_t position{6};
10462 static constexpr char const * const name{"n_relocs"};
10463 static constexpr char const * const typestr{"unsigned"};
10464 static constexpr bool traverse{false};
10465 static constexpr auto mbr_ptr{&SgAsmPESectionTableEntry::p_n_relocs};
10466 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10467 using bind = Desc<SgAsmPESectionTableEntry, unsigned SgAsmPESectionTableEntry::*, &SgAsmPESectionTableEntry::p_n_relocs>;
10468};
10469template <> struct describe_field_t<SgAsmPESectionTableEntry,unsigned,&SgAsmPESectionTableEntry::p_n_coff_line_nums> {
10471 using field_type = unsigned;
10472 static constexpr size_t position{7};
10473 static constexpr char const * const name{"n_coff_line_nums"};
10474 static constexpr char const * const typestr{"unsigned"};
10475 static constexpr bool traverse{false};
10476 static constexpr auto mbr_ptr{&SgAsmPESectionTableEntry::p_n_coff_line_nums};
10477 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10478 using bind = Desc<SgAsmPESectionTableEntry, unsigned SgAsmPESectionTableEntry::*, &SgAsmPESectionTableEntry::p_n_coff_line_nums>;
10479};
10480template <> struct describe_field_t<SgAsmPESectionTableEntry,unsigned,&SgAsmPESectionTableEntry::p_flags> {
10482 using field_type = unsigned;
10483 static constexpr size_t position{8};
10484 static constexpr char const * const name{"flags"};
10485 static constexpr char const * const typestr{"unsigned"};
10486 static constexpr bool traverse{false};
10487 static constexpr auto mbr_ptr{&SgAsmPESectionTableEntry::p_flags};
10488 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10489 using bind = Desc<SgAsmPESectionTableEntry, unsigned SgAsmPESectionTableEntry::*, &SgAsmPESectionTableEntry::p_flags>;
10490};
10500template <> struct node_from_variant_t<265> { using type = SgAsmPESectionTableEntry; };
10501
10502// Class: AsmPEStringSection
10503template <> struct describe_field_t<SgAsmPEStringSection,SgAsmCoffStrtab*,&SgAsmPEStringSection::p_strtab> {
10505 using field_type = SgAsmCoffStrtab*;
10506 static constexpr size_t position{0};
10507 static constexpr char const * const name{"strtab"};
10508 static constexpr char const * const typestr{"SgAsmCoffStrtab*"};
10509 static constexpr bool traverse{false};
10510 static constexpr auto mbr_ptr{&SgAsmPEStringSection::p_strtab};
10511 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10512 using bind = Desc<SgAsmPEStringSection, SgAsmCoffStrtab* SgAsmPEStringSection::*, &SgAsmPEStringSection::p_strtab>;
10513};
10515 using node = SgAsmPEStringSection;
10516 using base = SgAsmPESection;
10517 static constexpr char const * const name{"AsmPEStringSection"};
10518 static constexpr unsigned long variant{266};
10519 static constexpr bool concrete{true};
10520 using subclasses_t = mp::List<>;
10522};
10523template <> struct node_from_variant_t<266> { using type = SgAsmPEStringSection; };
10524
10525// Class: AsmPowerpcInstruction
10526template <> struct describe_field_t<SgAsmPowerpcInstruction,Rose::BinaryAnalysis::PowerpcInstructionKind,&SgAsmPowerpcInstruction::p_kind> {
10528 using field_type = Rose::BinaryAnalysis::PowerpcInstructionKind;
10529 static constexpr size_t position{0};
10530 static constexpr char const * const name{"kind"};
10531 static constexpr char const * const typestr{"Rose::BinaryAnalysis::PowerpcInstructionKind"};
10532 static constexpr bool traverse{false};
10533 static constexpr auto mbr_ptr{&SgAsmPowerpcInstruction::p_kind};
10534 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10535 using bind = Desc<SgAsmPowerpcInstruction, Rose::BinaryAnalysis::PowerpcInstructionKind SgAsmPowerpcInstruction::*, &SgAsmPowerpcInstruction::p_kind>;
10536};
10539 using base = SgAsmInstruction;
10540 static constexpr char const * const name{"AsmPowerpcInstruction"};
10541 static constexpr unsigned long variant{267};
10542 static constexpr bool concrete{true};
10543 using subclasses_t = mp::List<>;
10545};
10546template <> struct node_from_variant_t<267> { using type = SgAsmPowerpcInstruction; };
10547
10548// Class: AsmRegisterNames
10549template <> struct describe_field_t<SgAsmRegisterNames,SgAsmRegisterReferenceExpressionPtrList,&SgAsmRegisterNames::p_registers> {
10550 using parent = SgAsmRegisterNames;
10551 using field_type = SgAsmRegisterReferenceExpressionPtrList;
10552 static constexpr size_t position{0};
10553 static constexpr char const * const name{"registers"};
10554 static constexpr char const * const typestr{"SgAsmRegisterReferenceExpressionPtrList"};
10555 static constexpr bool traverse{true};
10556 static constexpr auto mbr_ptr{&SgAsmRegisterNames::p_registers};
10557 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10558 using bind = Desc<SgAsmRegisterNames, SgAsmRegisterReferenceExpressionPtrList SgAsmRegisterNames::*, &SgAsmRegisterNames::p_registers>;
10559};
10560template <> struct describe_field_t<SgAsmRegisterNames,unsigned,&SgAsmRegisterNames::p_mask> {
10561 using parent = SgAsmRegisterNames;
10562 using field_type = unsigned;
10563 static constexpr size_t position{1};
10564 static constexpr char const * const name{"mask"};
10565 static constexpr char const * const typestr{"unsigned"};
10566 static constexpr bool traverse{false};
10567 static constexpr auto mbr_ptr{&SgAsmRegisterNames::p_mask};
10568 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10569 using bind = Desc<SgAsmRegisterNames, unsigned SgAsmRegisterNames::*, &SgAsmRegisterNames::p_mask>;
10570};
10572 using node = SgAsmRegisterNames;
10573 using base = SgAsmExpression;
10574 static constexpr char const * const name{"AsmRegisterNames"};
10575 static constexpr unsigned long variant{268};
10576 static constexpr bool concrete{true};
10577 using subclasses_t = mp::List<>;
10579};
10580template <> struct node_from_variant_t<268> { using type = SgAsmRegisterNames; };
10581
10582// Class: AsmRegisterReferenceExpression
10583template <> struct describe_field_t<SgAsmRegisterReferenceExpression,Rose::BinaryAnalysis::RegisterDescriptor,&SgAsmRegisterReferenceExpression::p_descriptor> {
10586 static constexpr size_t position{0};
10587 static constexpr char const * const name{"descriptor"};
10588 static constexpr char const * const typestr{"Rose::BinaryAnalysis::RegisterDescriptor"};
10589 static constexpr bool traverse{false};
10590 static constexpr auto mbr_ptr{&SgAsmRegisterReferenceExpression::p_descriptor};
10591 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10592 using bind = Desc<SgAsmRegisterReferenceExpression, Rose::BinaryAnalysis::RegisterDescriptor SgAsmRegisterReferenceExpression::*, &SgAsmRegisterReferenceExpression::p_descriptor>;
10593};
10594template <> struct describe_field_t<SgAsmRegisterReferenceExpression,int,&SgAsmRegisterReferenceExpression::p_adjustment> {
10596 using field_type = int;
10597 static constexpr size_t position{1};
10598 static constexpr char const * const name{"adjustment"};
10599 static constexpr char const * const typestr{"int"};
10600 static constexpr bool traverse{false};
10601 static constexpr auto mbr_ptr{&SgAsmRegisterReferenceExpression::p_adjustment};
10602 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10603 using bind = Desc<SgAsmRegisterReferenceExpression, int SgAsmRegisterReferenceExpression::*, &SgAsmRegisterReferenceExpression::p_adjustment>;
10604};
10614template <> struct node_from_variant_t<269> { using type = SgAsmRegisterReferenceExpression; };
10615
10616// Class: AsmRiscOperation
10617template <> struct describe_field_t<SgAsmRiscOperation,SgAsmRiscOperation::RiscOperator,&SgAsmRiscOperation::p_riscOperator> {
10618 using parent = SgAsmRiscOperation;
10620 static constexpr size_t position{0};
10621 static constexpr char const * const name{"riscOperator"};
10622 static constexpr char const * const typestr{"SgAsmRiscOperation::RiscOperator"};
10623 static constexpr bool traverse{false};
10624 static constexpr auto mbr_ptr{&SgAsmRiscOperation::p_riscOperator};
10625 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10626 using bind = Desc<SgAsmRiscOperation, SgAsmRiscOperation::RiscOperator SgAsmRiscOperation::*, &SgAsmRiscOperation::p_riscOperator>;
10627};
10628template <> struct describe_field_t<SgAsmRiscOperation,SgAsmExprListExp*,&SgAsmRiscOperation::p_operands> {
10629 using parent = SgAsmRiscOperation;
10631 static constexpr size_t position{1};
10632 static constexpr char const * const name{"operands"};
10633 static constexpr char const * const typestr{"SgAsmExprListExp*"};
10634 static constexpr bool traverse{true};
10635 static constexpr auto mbr_ptr{&SgAsmRiscOperation::p_operands};
10636 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10637 using bind = Desc<SgAsmRiscOperation, SgAsmExprListExp* SgAsmRiscOperation::*, &SgAsmRiscOperation::p_operands>;
10638};
10640 using node = SgAsmRiscOperation;
10641 using base = SgAsmExpression;
10642 static constexpr char const * const name{"AsmRiscOperation"};
10643 static constexpr unsigned long variant{270};
10644 static constexpr bool concrete{true};
10645 using subclasses_t = mp::List<>;
10647};
10648template <> struct node_from_variant_t<270> { using type = SgAsmRiscOperation; };
10649
10650// Class: AsmScalarType
10651template <> struct describe_field_t<SgAsmScalarType,Rose::BinaryAnalysis::ByteOrder::Endianness,&SgAsmScalarType::p_minorOrder> {
10652 using parent = SgAsmScalarType;
10654 static constexpr size_t position{0};
10655 static constexpr char const * const name{"minorOrder"};
10656 static constexpr char const * const typestr{"Rose::BinaryAnalysis::ByteOrder::Endianness"};
10657 static constexpr bool traverse{false};
10658 static constexpr auto mbr_ptr{&SgAsmScalarType::p_minorOrder};
10659 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10660 using bind = Desc<SgAsmScalarType, Rose::BinaryAnalysis::ByteOrder::Endianness SgAsmScalarType::*, &SgAsmScalarType::p_minorOrder>;
10661};
10662template <> struct describe_field_t<SgAsmScalarType,Rose::BinaryAnalysis::ByteOrder::Endianness,&SgAsmScalarType::p_majorOrder> {
10663 using parent = SgAsmScalarType;
10665 static constexpr size_t position{1};
10666 static constexpr char const * const name{"majorOrder"};
10667 static constexpr char const * const typestr{"Rose::BinaryAnalysis::ByteOrder::Endianness"};
10668 static constexpr bool traverse{false};
10669 static constexpr auto mbr_ptr{&SgAsmScalarType::p_majorOrder};
10670 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10671 using bind = Desc<SgAsmScalarType, Rose::BinaryAnalysis::ByteOrder::Endianness SgAsmScalarType::*, &SgAsmScalarType::p_majorOrder>;
10672};
10673template <> struct describe_field_t<SgAsmScalarType,size_t,&SgAsmScalarType::p_majorNBytes> {
10674 using parent = SgAsmScalarType;
10675 using field_type = size_t;
10676 static constexpr size_t position{2};
10677 static constexpr char const * const name{"majorNBytes"};
10678 static constexpr char const * const typestr{"size_t"};
10679 static constexpr bool traverse{false};
10680 static constexpr auto mbr_ptr{&SgAsmScalarType::p_majorNBytes};
10681 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10682 using bind = Desc<SgAsmScalarType, size_t SgAsmScalarType::*, &SgAsmScalarType::p_majorNBytes>;
10683};
10684template <> struct describe_field_t<SgAsmScalarType,size_t,&SgAsmScalarType::p_nBits> {
10685 using parent = SgAsmScalarType;
10686 using field_type = size_t;
10687 static constexpr size_t position{3};
10688 static constexpr char const * const name{"nBits"};
10689 static constexpr char const * const typestr{"size_t"};
10690 static constexpr bool traverse{false};
10691 static constexpr auto mbr_ptr{&SgAsmScalarType::p_nBits};
10692 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10693 using bind = Desc<SgAsmScalarType, size_t SgAsmScalarType::*, &SgAsmScalarType::p_nBits>;
10694};
10704template <> struct node_from_variant_t<271> { using type = SgAsmScalarType; };
10705
10706// Class: AsmStatement
10707template <> struct describe_field_t<SgAsmStatement,Rose::BinaryAnalysis::Address,&SgAsmStatement::p_address> {
10708 using parent = SgAsmStatement;
10709 using field_type = Rose::BinaryAnalysis::Address;
10710 static constexpr size_t position{0};
10711 static constexpr char const * const name{"address"};
10712 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
10713 static constexpr bool traverse{false};
10714 static constexpr auto mbr_ptr{&SgAsmStatement::p_address};
10715 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10716 using bind = Desc<SgAsmStatement, Rose::BinaryAnalysis::Address SgAsmStatement::*, &SgAsmStatement::p_address>;
10717};
10718template <> struct describe_field_t<SgAsmStatement,std::string,&SgAsmStatement::p_comment> {
10719 using parent = SgAsmStatement;
10720 using field_type = std::string;
10721 static constexpr size_t position{1};
10722 static constexpr char const * const name{"comment"};
10723 static constexpr char const * const typestr{"std::string"};
10724 static constexpr bool traverse{false};
10725 static constexpr auto mbr_ptr{&SgAsmStatement::p_comment};
10726 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10727 using bind = Desc<SgAsmStatement, std::string SgAsmStatement::*, &SgAsmStatement::p_comment>;
10728};
10729template <> struct describe_node_t<SgAsmStatement> {
10730 using node = SgAsmStatement;
10731 using base = SgAsmNode;
10732 static constexpr char const * const name{"AsmStatement"};
10733 static constexpr unsigned long variant{272};
10734 static constexpr bool concrete{false};
10737};
10738template <> struct node_from_variant_t<272> { using type = SgAsmStatement; };
10739
10740// Class: AsmStaticData
10741template <> struct describe_field_t<SgAsmStaticData,SgUnsignedCharList,&SgAsmStaticData::p_rawBytes> {
10742 using parent = SgAsmStaticData;
10743 using field_type = SgUnsignedCharList;
10744 static constexpr size_t position{0};
10745 static constexpr char const * const name{"rawBytes"};
10746 static constexpr char const * const typestr{"SgUnsignedCharList"};
10747 static constexpr bool traverse{false};
10748 static constexpr auto mbr_ptr{&SgAsmStaticData::p_rawBytes};
10749 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10750 using bind = Desc<SgAsmStaticData, SgUnsignedCharList SgAsmStaticData::*, &SgAsmStaticData::p_rawBytes>;
10751};
10753 using node = SgAsmStaticData;
10754 using base = SgAsmStatement;
10755 static constexpr char const * const name{"AsmStaticData"};
10756 static constexpr unsigned long variant{273};
10757 static constexpr bool concrete{true};
10758 using subclasses_t = mp::List<>;
10760};
10761template <> struct node_from_variant_t<273> { using type = SgAsmStaticData; };
10762
10763// Class: AsmStmt
10764template <> struct describe_field_t<SgAsmStmt,std::string,&SgAsmStmt::p_assemblyCode> {
10765 using parent = SgAsmStmt;
10766 using field_type = std::string;
10767 static constexpr size_t position{0};
10768 static constexpr char const * const name{"assemblyCode"};
10769 static constexpr char const * const typestr{"std::string"};
10770 static constexpr bool traverse{false};
10771 static constexpr auto mbr_ptr{&SgAsmStmt::p_assemblyCode};
10772 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10773 using bind = Desc<SgAsmStmt, std::string SgAsmStmt::*, &SgAsmStmt::p_assemblyCode>;
10774};
10775template <> struct describe_field_t<SgAsmStmt,bool,&SgAsmStmt::p_useGnuExtendedFormat> {
10776 using parent = SgAsmStmt;
10777 using field_type = bool;
10778 static constexpr size_t position{1};
10779 static constexpr char const * const name{"useGnuExtendedFormat"};
10780 static constexpr char const * const typestr{"bool"};
10781 static constexpr bool traverse{false};
10782 static constexpr auto mbr_ptr{&SgAsmStmt::p_useGnuExtendedFormat};
10783 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10784 using bind = Desc<SgAsmStmt, bool SgAsmStmt::*, &SgAsmStmt::p_useGnuExtendedFormat>;
10785};
10786template <> struct describe_field_t<SgAsmStmt,SgExpressionPtrList,&SgAsmStmt::p_operands> {
10787 using parent = SgAsmStmt;
10788 using field_type = SgExpressionPtrList;
10789 static constexpr size_t position{2};
10790 static constexpr char const * const name{"operands"};
10791 static constexpr char const * const typestr{"SgExpressionPtrList"};
10792 static constexpr bool traverse{true};
10793 static constexpr auto mbr_ptr{&SgAsmStmt::p_operands};
10794 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10795 using bind = Desc<SgAsmStmt, SgExpressionPtrList SgAsmStmt::*, &SgAsmStmt::p_operands>;
10796};
10798 using parent = SgAsmStmt;
10799 using field_type = SgAsmStmt::AsmRegisterNameList;
10800 static constexpr size_t position{3};
10801 static constexpr char const * const name{"clobberRegisterList"};
10802 static constexpr char const * const typestr{"SgAsmStmt::AsmRegisterNameList"};
10803 static constexpr bool traverse{false};
10804 static constexpr auto mbr_ptr{&SgAsmStmt::p_clobberRegisterList};
10805 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10806 using bind = Desc<SgAsmStmt, SgAsmStmt::AsmRegisterNameList SgAsmStmt::*, &SgAsmStmt::p_clobberRegisterList>;
10807};
10808template <> struct describe_field_t<SgAsmStmt,bool,&SgAsmStmt::p_isVolatile> {
10809 using parent = SgAsmStmt;
10810 using field_type = bool;
10811 static constexpr size_t position{4};
10812 static constexpr char const * const name{"isVolatile"};
10813 static constexpr char const * const typestr{"bool"};
10814 static constexpr bool traverse{false};
10815 static constexpr auto mbr_ptr{&SgAsmStmt::p_isVolatile};
10816 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10817 using bind = Desc<SgAsmStmt, bool SgAsmStmt::*, &SgAsmStmt::p_isVolatile>;
10818};
10828template <> struct node_from_variant_t<274> { using type = SgAsmStmt; };
10829
10830// Class: AsmStoredString
10831template <> struct describe_field_t<SgAsmStoredString,SgAsmStringStorage*,&SgAsmStoredString::p_storage> {
10832 using parent = SgAsmStoredString;
10834 static constexpr size_t position{0};
10835 static constexpr char const * const name{"storage"};
10836 static constexpr char const * const typestr{"SgAsmStringStorage*"};
10837 static constexpr bool traverse{false};
10838 static constexpr auto mbr_ptr{&SgAsmStoredString::p_storage};
10839 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10840 using bind = Desc<SgAsmStoredString, SgAsmStringStorage* SgAsmStoredString::*, &SgAsmStoredString::p_storage>;
10841};
10843 using node = SgAsmStoredString;
10844 using base = SgAsmGenericString;
10845 static constexpr char const * const name{"AsmStoredString"};
10846 static constexpr unsigned long variant{275};
10847 static constexpr bool concrete{true};
10848 using subclasses_t = mp::List<>;
10850};
10851template <> struct node_from_variant_t<275> { using type = SgAsmStoredString; };
10852
10853// Class: AsmStringStorage
10854template <> struct describe_field_t<SgAsmStringStorage,SgAsmGenericStrtab*,&SgAsmStringStorage::p_strtab> {
10855 using parent = SgAsmStringStorage;
10857 static constexpr size_t position{0};
10858 static constexpr char const * const name{"strtab"};
10859 static constexpr char const * const typestr{"SgAsmGenericStrtab*"};
10860 static constexpr bool traverse{false};
10861 static constexpr auto mbr_ptr{&SgAsmStringStorage::p_strtab};
10862 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10863 using bind = Desc<SgAsmStringStorage, SgAsmGenericStrtab* SgAsmStringStorage::*, &SgAsmStringStorage::p_strtab>;
10864};
10865template <> struct describe_field_t<SgAsmStringStorage,std::string,&SgAsmStringStorage::p_string> {
10866 using parent = SgAsmStringStorage;
10867 using field_type = std::string;
10868 static constexpr size_t position{1};
10869 static constexpr char const * const name{"string"};
10870 static constexpr char const * const typestr{"std::string"};
10871 static constexpr bool traverse{false};
10872 static constexpr auto mbr_ptr{&SgAsmStringStorage::p_string};
10873 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10874 using bind = Desc<SgAsmStringStorage, std::string SgAsmStringStorage::*, &SgAsmStringStorage::p_string>;
10875};
10876template <> struct describe_field_t<SgAsmStringStorage,Rose::BinaryAnalysis::Address,&SgAsmStringStorage::p_offset> {
10877 using parent = SgAsmStringStorage;
10878 using field_type = Rose::BinaryAnalysis::Address;
10879 static constexpr size_t position{2};
10880 static constexpr char const * const name{"offset"};
10881 static constexpr char const * const typestr{"Rose::BinaryAnalysis::Address"};
10882 static constexpr bool traverse{false};
10883 static constexpr auto mbr_ptr{&SgAsmStringStorage::p_offset};
10884 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10885 using bind = Desc<SgAsmStringStorage, Rose::BinaryAnalysis::Address SgAsmStringStorage::*, &SgAsmStringStorage::p_offset>;
10886};
10888 using node = SgAsmStringStorage;
10890 static constexpr char const * const name{"AsmStringStorage"};
10891 static constexpr unsigned long variant{276};
10892 static constexpr bool concrete{true};
10893 using subclasses_t = mp::List<>;
10895};
10896template <> struct node_from_variant_t<276> { using type = SgAsmStringStorage; };
10897
10898// Class: AsmType
10899template <> struct describe_node_t<SgAsmType> {
10900 using node = SgAsmType;
10901 using base = SgAsmNode;
10902 static constexpr char const * const name{"AsmType"};
10903 static constexpr unsigned long variant{277};
10904 static constexpr bool concrete{false};
10906 using fields_t = mp::List<>;
10907};
10908template <> struct node_from_variant_t<277> { using type = SgAsmType; };
10909
10910// Class: AsmUnaryExpression
10911template <> struct describe_field_t<SgAsmUnaryExpression,SgAsmExpression*,&SgAsmUnaryExpression::p_operand> {
10913 using field_type = SgAsmExpression*;
10914 static constexpr size_t position{0};
10915 static constexpr char const * const name{"operand"};
10916 static constexpr char const * const typestr{"SgAsmExpression*"};
10917 static constexpr bool traverse{true};
10918 static constexpr auto mbr_ptr{&SgAsmUnaryExpression::p_operand};
10919 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
10920 using bind = Desc<SgAsmUnaryExpression, SgAsmExpression* SgAsmUnaryExpression::*, &SgAsmUnaryExpression::p_operand>;
10921};
10923 using node = SgAsmUnaryExpression;
10924 using base = SgAsmExpression;
10925 static constexpr char const * const name{"AsmUnaryExpression"};
10926 static constexpr unsigned long variant{278};
10927 static constexpr bool concrete{false};
10930};
10931template <> struct node_from_variant_t<278> { using type = SgAsmUnaryExpression; };
10932
10933// Class: AsmUnaryMinus
10935 using node = SgAsmUnaryMinus;
10936 using base = SgAsmUnaryExpression;
10937 static constexpr char const * const name{"AsmUnaryMinus"};
10938 static constexpr unsigned long variant{279};
10939 static constexpr bool concrete{true};
10940 using subclasses_t = mp::List<>;
10941 using fields_t = mp::List<>;
10942};
10943template <> struct node_from_variant_t<279> { using type = SgAsmUnaryMinus; };
10944
10945// Class: AsmUnaryPlus
10946template <> struct describe_node_t<SgAsmUnaryPlus> {
10947 using node = SgAsmUnaryPlus;
10948 using base = SgAsmUnaryExpression;
10949 static constexpr char const * const name{"AsmUnaryPlus"};
10950 static constexpr unsigned long variant{280};
10951 static constexpr bool concrete{true};
10952 using subclasses_t = mp::List<>;
10953 using fields_t = mp::List<>;
10954};
10955template <> struct node_from_variant_t<280> { using type = SgAsmUnaryPlus; };
10956
10957// Class: AsmUnaryRrx
10958template <> struct describe_node_t<SgAsmUnaryRrx> {
10959 using node = SgAsmUnaryRrx;
10960 using base = SgAsmUnaryExpression;
10961 static constexpr char const * const name{"AsmUnaryRrx"};
10962 static constexpr unsigned long variant{281};
10963 static constexpr bool concrete{true};
10964 using subclasses_t = mp::List<>;
10965 using fields_t = mp::List<>;
10966};
10967template <> struct node_from_variant_t<281> { using type = SgAsmUnaryRrx; };
10968
10969// Class: AsmUnarySignedExtend
10972 using base = SgAsmUnaryExpression;
10973 static constexpr char const * const name{"AsmUnarySignedExtend"};
10974 static constexpr unsigned long variant{282};
10975 static constexpr bool concrete{true};
10976 using subclasses_t = mp::List<>;
10977 using fields_t = mp::List<>;
10978};
10979template <> struct node_from_variant_t<282> { using type = SgAsmUnarySignedExtend; };
10980
10981// Class: AsmUnaryUnsignedExtend
10984 using base = SgAsmUnaryExpression;
10985 static constexpr char const * const name{"AsmUnaryUnsignedExtend"};
10986 static constexpr unsigned long variant{283};
10987 static constexpr bool concrete{true};
10988 using subclasses_t = mp::List<>;
10989 using fields_t = mp::List<>;
10990};
10991template <> struct node_from_variant_t<283> { using type = SgAsmUnaryUnsignedExtend; };
10992
10993// Class: AsmUnaryTruncate
10995 using node = SgAsmUnaryTruncate;
10996 using base = SgAsmUnaryExpression;
10997 static constexpr char const * const name{"AsmUnaryTruncate"};
10998 static constexpr unsigned long variant{284};
10999 static constexpr bool concrete{true};
11000 using subclasses_t = mp::List<>;
11001 using fields_t = mp::List<>;
11002};
11003template <> struct node_from_variant_t<284> { using type = SgAsmUnaryTruncate; };
11004
11005// Class: AsmValueExpression
11006template <> struct describe_field_t<SgAsmValueExpression,SgAsmValueExpression*,&SgAsmValueExpression::p_unfoldedExpression> {
11009 static constexpr size_t position{0};
11010 static constexpr char const * const name{"unfoldedExpression"};
11011 static constexpr char const * const typestr{"SgAsmValueExpression*"};
11012 static constexpr bool traverse{true};
11013 static constexpr auto mbr_ptr{&SgAsmValueExpression::p_unfoldedExpression};
11014 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11015 using bind = Desc<SgAsmValueExpression, SgAsmValueExpression* SgAsmValueExpression::*, &SgAsmValueExpression::p_unfoldedExpression>;
11016};
11017template <> struct describe_field_t<SgAsmValueExpression,unsigned short,&SgAsmValueExpression::p_bitOffset> {
11019 using field_type = unsigned short;
11020 static constexpr size_t position{1};
11021 static constexpr char const * const name{"bitOffset"};
11022 static constexpr char const * const typestr{"unsigned short"};
11023 static constexpr bool traverse{false};
11024 static constexpr auto mbr_ptr{&SgAsmValueExpression::p_bitOffset};
11025 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11026 using bind = Desc<SgAsmValueExpression, unsigned short SgAsmValueExpression::*, &SgAsmValueExpression::p_bitOffset>;
11027};
11028template <> struct describe_field_t<SgAsmValueExpression,unsigned short,&SgAsmValueExpression::p_bitSize> {
11030 using field_type = unsigned short;
11031 static constexpr size_t position{2};
11032 static constexpr char const * const name{"bitSize"};
11033 static constexpr char const * const typestr{"unsigned short"};
11034 static constexpr bool traverse{false};
11035 static constexpr auto mbr_ptr{&SgAsmValueExpression::p_bitSize};
11036 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11037 using bind = Desc<SgAsmValueExpression, unsigned short SgAsmValueExpression::*, &SgAsmValueExpression::p_bitSize>;
11038};
11039template <> struct describe_field_t<SgAsmValueExpression,SgSymbol*,&SgAsmValueExpression::p_symbol> {
11041 using field_type = SgSymbol*;
11042 static constexpr size_t position{3};
11043 static constexpr char const * const name{"symbol"};
11044 static constexpr char const * const typestr{"SgSymbol*"};
11045 static constexpr bool traverse{false};
11046 static constexpr auto mbr_ptr{&SgAsmValueExpression::p_symbol};
11047 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11048 using bind = Desc<SgAsmValueExpression, SgSymbol* SgAsmValueExpression::*, &SgAsmValueExpression::p_symbol>;
11049};
11059template <> struct node_from_variant_t<285> { using type = SgAsmValueExpression; };
11060
11061// Class: AsmVectorType
11062template <> struct describe_field_t<SgAsmVectorType,size_t,&SgAsmVectorType::p_nElmts> {
11063 using parent = SgAsmVectorType;
11064 using field_type = size_t;
11065 static constexpr size_t position{0};
11066 static constexpr char const * const name{"nElmts"};
11067 static constexpr char const * const typestr{"size_t"};
11068 static constexpr bool traverse{false};
11069 static constexpr auto mbr_ptr{&SgAsmVectorType::p_nElmts};
11070 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11071 using bind = Desc<SgAsmVectorType, size_t SgAsmVectorType::*, &SgAsmVectorType::p_nElmts>;
11072};
11073template <> struct describe_field_t<SgAsmVectorType,SgAsmType*,&SgAsmVectorType::p_elmtType> {
11074 using parent = SgAsmVectorType;
11075 using field_type = SgAsmType*;
11076 static constexpr size_t position{1};
11077 static constexpr char const * const name{"elmtType"};
11078 static constexpr char const * const typestr{"SgAsmType*"};
11079 static constexpr bool traverse{false};
11080 static constexpr auto mbr_ptr{&SgAsmVectorType::p_elmtType};
11081 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11082 using bind = Desc<SgAsmVectorType, SgAsmType* SgAsmVectorType::*, &SgAsmVectorType::p_elmtType>;
11083};
11085 using node = SgAsmVectorType;
11086 using base = SgAsmType;
11087 static constexpr char const * const name{"AsmVectorType"};
11088 static constexpr unsigned long variant{286};
11089 static constexpr bool concrete{true};
11090 using subclasses_t = mp::List<>;
11092};
11093template <> struct node_from_variant_t<286> { using type = SgAsmVectorType; };
11094
11095// Class: AsmX86Instruction
11096template <> struct describe_field_t<SgAsmX86Instruction,Rose::BinaryAnalysis::X86InstructionKind,&SgAsmX86Instruction::p_kind> {
11099 static constexpr size_t position{0};
11100 static constexpr char const * const name{"kind"};
11101 static constexpr char const * const typestr{"Rose::BinaryAnalysis::X86InstructionKind"};
11102 static constexpr bool traverse{false};
11103 static constexpr auto mbr_ptr{&SgAsmX86Instruction::p_kind};
11104 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11105 using bind = Desc<SgAsmX86Instruction, Rose::BinaryAnalysis::X86InstructionKind SgAsmX86Instruction::*, &SgAsmX86Instruction::p_kind>;
11106};
11107template <> struct describe_field_t<SgAsmX86Instruction,Rose::BinaryAnalysis::X86InstructionSize,&SgAsmX86Instruction::p_baseSize> {
11109 using field_type = Rose::BinaryAnalysis::X86InstructionSize;
11110 static constexpr size_t position{1};
11111 static constexpr char const * const name{"baseSize"};
11112 static constexpr char const * const typestr{"Rose::BinaryAnalysis::X86InstructionSize"};
11113 static constexpr bool traverse{false};
11114 static constexpr auto mbr_ptr{&SgAsmX86Instruction::p_baseSize};
11115 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11116 using bind = Desc<SgAsmX86Instruction, Rose::BinaryAnalysis::X86InstructionSize SgAsmX86Instruction::*, &SgAsmX86Instruction::p_baseSize>;
11117};
11118template <> struct describe_field_t<SgAsmX86Instruction,Rose::BinaryAnalysis::X86InstructionSize,&SgAsmX86Instruction::p_operandSize> {
11120 using field_type = Rose::BinaryAnalysis::X86InstructionSize;
11121 static constexpr size_t position{2};
11122 static constexpr char const * const name{"operandSize"};
11123 static constexpr char const * const typestr{"Rose::BinaryAnalysis::X86InstructionSize"};
11124 static constexpr bool traverse{false};
11125 static constexpr auto mbr_ptr{&SgAsmX86Instruction::p_operandSize};
11126 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11127 using bind = Desc<SgAsmX86Instruction, Rose::BinaryAnalysis::X86InstructionSize SgAsmX86Instruction::*, &SgAsmX86Instruction::p_operandSize>;
11128};
11129template <> struct describe_field_t<SgAsmX86Instruction,Rose::BinaryAnalysis::X86InstructionSize,&SgAsmX86Instruction::p_addressSize> {
11131 using field_type = Rose::BinaryAnalysis::X86InstructionSize;
11132 static constexpr size_t position{3};
11133 static constexpr char const * const name{"addressSize"};
11134 static constexpr char const * const typestr{"Rose::BinaryAnalysis::X86InstructionSize"};
11135 static constexpr bool traverse{false};
11136 static constexpr auto mbr_ptr{&SgAsmX86Instruction::p_addressSize};
11137 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11138 using bind = Desc<SgAsmX86Instruction, Rose::BinaryAnalysis::X86InstructionSize SgAsmX86Instruction::*, &SgAsmX86Instruction::p_addressSize>;
11139};
11140template <> struct describe_field_t<SgAsmX86Instruction,bool,&SgAsmX86Instruction::p_lockPrefix> {
11142 using field_type = bool;
11143 static constexpr size_t position{4};
11144 static constexpr char const * const name{"lockPrefix"};
11145 static constexpr char const * const typestr{"bool"};
11146 static constexpr bool traverse{false};
11147 static constexpr auto mbr_ptr{&SgAsmX86Instruction::p_lockPrefix};
11148 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11149 using bind = Desc<SgAsmX86Instruction, bool SgAsmX86Instruction::*, &SgAsmX86Instruction::p_lockPrefix>;
11150};
11151template <> struct describe_field_t<SgAsmX86Instruction,Rose::BinaryAnalysis::X86RepeatPrefix,&SgAsmX86Instruction::p_repeatPrefix> {
11153 using field_type = Rose::BinaryAnalysis::X86RepeatPrefix;
11154 static constexpr size_t position{5};
11155 static constexpr char const * const name{"repeatPrefix"};
11156 static constexpr char const * const typestr{"Rose::BinaryAnalysis::X86RepeatPrefix"};
11157 static constexpr bool traverse{false};
11158 static constexpr auto mbr_ptr{&SgAsmX86Instruction::p_repeatPrefix};
11159 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11160 using bind = Desc<SgAsmX86Instruction, Rose::BinaryAnalysis::X86RepeatPrefix SgAsmX86Instruction::*, &SgAsmX86Instruction::p_repeatPrefix>;
11161};
11162template <> struct describe_field_t<SgAsmX86Instruction,Rose::BinaryAnalysis::X86BranchPrediction,&SgAsmX86Instruction::p_branchPrediction> {
11164 using field_type = Rose::BinaryAnalysis::X86BranchPrediction;
11165 static constexpr size_t position{6};
11166 static constexpr char const * const name{"branchPrediction"};
11167 static constexpr char const * const typestr{"Rose::BinaryAnalysis::X86BranchPrediction"};
11168 static constexpr bool traverse{false};
11169 static constexpr auto mbr_ptr{&SgAsmX86Instruction::p_branchPrediction};
11170 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11171 using bind = Desc<SgAsmX86Instruction, Rose::BinaryAnalysis::X86BranchPrediction SgAsmX86Instruction::*, &SgAsmX86Instruction::p_branchPrediction>;
11172};
11173template <> struct describe_field_t<SgAsmX86Instruction,Rose::BinaryAnalysis::X86SegmentRegister,&SgAsmX86Instruction::p_segmentOverride> {
11175 using field_type = Rose::BinaryAnalysis::X86SegmentRegister;
11176 static constexpr size_t position{7};
11177 static constexpr char const * const name{"segmentOverride"};
11178 static constexpr char const * const typestr{"Rose::BinaryAnalysis::X86SegmentRegister"};
11179 static constexpr bool traverse{false};
11180 static constexpr auto mbr_ptr{&SgAsmX86Instruction::p_segmentOverride};
11181 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11182 using bind = Desc<SgAsmX86Instruction, Rose::BinaryAnalysis::X86SegmentRegister SgAsmX86Instruction::*, &SgAsmX86Instruction::p_segmentOverride>;
11183};
11193template <> struct node_from_variant_t<287> { using type = SgAsmX86Instruction; };
11194
11195// Class: AsmBinaryAddressSymbol
11196template <> struct describe_field_t<SgAsmBinaryAddressSymbol,SgName,&SgAsmBinaryAddressSymbol::p_address_name> {
11198 using field_type = SgName;
11199 static constexpr size_t position{0};
11200 static constexpr char const * const name{"address_name"};
11201 static constexpr char const * const typestr{"SgName"};
11202 static constexpr bool traverse{false};
11203 static constexpr auto mbr_ptr{&SgAsmBinaryAddressSymbol::p_address_name};
11204 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11205 using bind = Desc<SgAsmBinaryAddressSymbol, SgName SgAsmBinaryAddressSymbol::*, &SgAsmBinaryAddressSymbol::p_address_name>;
11206};
11207template <> struct describe_field_t<SgAsmBinaryAddressSymbol,SgAsmInstruction*,&SgAsmBinaryAddressSymbol::p_address> {
11210 static constexpr size_t position{1};
11211 static constexpr char const * const name{"address"};
11212 static constexpr char const * const typestr{"SgAsmInstruction*"};
11213 static constexpr bool traverse{false};
11214 static constexpr auto mbr_ptr{&SgAsmBinaryAddressSymbol::p_address};
11215 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11216 using bind = Desc<SgAsmBinaryAddressSymbol, SgAsmInstruction* SgAsmBinaryAddressSymbol::*, &SgAsmBinaryAddressSymbol::p_address>;
11217};
11220 using base = SgSymbol;
11221 static constexpr char const * const name{"AsmBinaryAddressSymbol"};
11222 static constexpr unsigned long variant{288};
11223 static constexpr bool concrete{true};
11224 using subclasses_t = mp::List<>;
11226};
11227template <> struct node_from_variant_t<288> { using type = SgAsmBinaryAddressSymbol; };
11228
11229// Class: AsmBinaryDataSymbol
11230template <> struct describe_field_t<SgAsmBinaryDataSymbol,SgName,&SgAsmBinaryDataSymbol::p_variable_name> {
11232 using field_type = SgName;
11233 static constexpr size_t position{0};
11234 static constexpr char const * const name{"variable_name"};
11235 static constexpr char const * const typestr{"SgName"};
11236 static constexpr bool traverse{false};
11237 static constexpr auto mbr_ptr{&SgAsmBinaryDataSymbol::p_variable_name};
11238 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11239 using bind = Desc<SgAsmBinaryDataSymbol, SgName SgAsmBinaryDataSymbol::*, &SgAsmBinaryDataSymbol::p_variable_name>;
11240};
11241template <> struct describe_field_t<SgAsmBinaryDataSymbol,SgAsmInstruction*,&SgAsmBinaryDataSymbol::p_address> {
11244 static constexpr size_t position{1};
11245 static constexpr char const * const name{"address"};
11246 static constexpr char const * const typestr{"SgAsmInstruction*"};
11247 static constexpr bool traverse{false};
11248 static constexpr auto mbr_ptr{&SgAsmBinaryDataSymbol::p_address};
11249 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11250 using bind = Desc<SgAsmBinaryDataSymbol, SgAsmInstruction* SgAsmBinaryDataSymbol::*, &SgAsmBinaryDataSymbol::p_address>;
11251};
11254 using base = SgSymbol;
11255 static constexpr char const * const name{"AsmBinaryDataSymbol"};
11256 static constexpr unsigned long variant{289};
11257 static constexpr bool concrete{true};
11258 using subclasses_t = mp::List<>;
11260};
11261template <> struct node_from_variant_t<289> { using type = SgAsmBinaryDataSymbol; };
11262
11263// Class: AssertStmt
11264template <> struct describe_field_t<SgAssertStmt,SgExpression*,&SgAssertStmt::p_test> {
11265 using parent = SgAssertStmt;
11266 using field_type = SgExpression*;
11267 static constexpr size_t position{0};
11268 static constexpr char const * const name{"test"};
11269 static constexpr char const * const typestr{"SgExpression*"};
11270 static constexpr bool traverse{true};
11271 static constexpr auto mbr_ptr{&SgAssertStmt::p_test};
11272 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11273 using bind = Desc<SgAssertStmt, SgExpression* SgAssertStmt::*, &SgAssertStmt::p_test>;
11274};
11275template <> struct describe_field_t<SgAssertStmt,SgExpression*,&SgAssertStmt::p_exception_argument> {
11276 using parent = SgAssertStmt;
11277 using field_type = SgExpression*;
11278 static constexpr size_t position{1};
11279 static constexpr char const * const name{"exception_argument"};
11280 static constexpr char const * const typestr{"SgExpression*"};
11281 static constexpr bool traverse{true};
11282 static constexpr auto mbr_ptr{&SgAssertStmt::p_exception_argument};
11283 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11284 using bind = Desc<SgAssertStmt, SgExpression* SgAssertStmt::*, &SgAssertStmt::p_exception_argument>;
11285};
11286template <> struct describe_node_t<SgAssertStmt> {
11287 using node = SgAssertStmt;
11288 using base = SgStatement;
11289 static constexpr char const * const name{"AssertStmt"};
11290 static constexpr unsigned long variant{290};
11291 static constexpr bool concrete{true};
11292 using subclasses_t = mp::List<>;
11294};
11295template <> struct node_from_variant_t<290> { using type = SgAssertStmt; };
11296
11297// Class: AssignInitializer
11300 using field_type = SgExpression*;
11301 static constexpr size_t position{0};
11302 static constexpr char const * const name{"operand_i"};
11303 static constexpr char const * const typestr{"SgExpression*"};
11304 static constexpr bool traverse{true};
11305 static constexpr auto mbr_ptr{&SgAssignInitializer::p_operand_i};
11306 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11307 using bind = Desc<SgAssignInitializer, SgExpression* SgAssignInitializer::*, &SgAssignInitializer::p_operand_i>;
11308};
11311 using field_type = SgType*;
11312 static constexpr size_t position{1};
11313 static constexpr char const * const name{"expression_type"};
11314 static constexpr char const * const typestr{"SgType*"};
11315 static constexpr bool traverse{false};
11316 static constexpr auto mbr_ptr{&SgAssignInitializer::p_expression_type};
11317 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11318 using bind = Desc<SgAssignInitializer, SgType* SgAssignInitializer::*, &SgAssignInitializer::p_expression_type>;
11319};
11321 using node = SgAssignInitializer;
11322 using base = SgInitializer;
11323 static constexpr char const * const name{"AssignInitializer"};
11324 static constexpr unsigned long variant{291};
11325 static constexpr bool concrete{true};
11326 using subclasses_t = mp::List<>;
11328};
11329template <> struct node_from_variant_t<291> { using type = SgAssignInitializer; };
11330
11331// Class: AssignOp
11332template <> struct describe_node_t<SgAssignOp> {
11333 using node = SgAssignOp;
11334 using base = SgBinaryOp;
11335 static constexpr char const * const name{"AssignOp"};
11336 static constexpr unsigned long variant{292};
11337 static constexpr bool concrete{true};
11338 using subclasses_t = mp::List<>;
11339 using fields_t = mp::List<>;
11340};
11341template <> struct node_from_variant_t<292> { using type = SgAssignOp; };
11342
11343// Class: AssignStatement
11344template <> struct describe_field_t<SgAssignStatement,SgLabelRefExp*,&SgAssignStatement::p_label> {
11345 using parent = SgAssignStatement;
11346 using field_type = SgLabelRefExp*;
11347 static constexpr size_t position{0};
11348 static constexpr char const * const name{"label"};
11349 static constexpr char const * const typestr{"SgLabelRefExp*"};
11350 static constexpr bool traverse{false};
11351 static constexpr auto mbr_ptr{&SgAssignStatement::p_label};
11352 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11353 using bind = Desc<SgAssignStatement, SgLabelRefExp* SgAssignStatement::*, &SgAssignStatement::p_label>;
11354};
11355template <> struct describe_field_t<SgAssignStatement,SgExpression*,&SgAssignStatement::p_value> {
11356 using parent = SgAssignStatement;
11357 using field_type = SgExpression*;
11358 static constexpr size_t position{1};
11359 static constexpr char const * const name{"value"};
11360 static constexpr char const * const typestr{"SgExpression*"};
11361 static constexpr bool traverse{true};
11362 static constexpr auto mbr_ptr{&SgAssignStatement::p_value};
11363 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11364 using bind = Desc<SgAssignStatement, SgExpression* SgAssignStatement::*, &SgAssignStatement::p_value>;
11365};
11367 using node = SgAssignStatement;
11368 using base = SgStatement;
11369 static constexpr char const * const name{"AssignStatement"};
11370 static constexpr unsigned long variant{293};
11371 static constexpr bool concrete{true};
11372 using subclasses_t = mp::List<>;
11374};
11375template <> struct node_from_variant_t<293> { using type = SgAssignStatement; };
11376
11377// Class: AssignedGotoStatement
11378template <> struct describe_field_t<SgAssignedGotoStatement,SgExprListExp*,&SgAssignedGotoStatement::p_targets> {
11380 using field_type = SgExprListExp*;
11381 static constexpr size_t position{0};
11382 static constexpr char const * const name{"targets"};
11383 static constexpr char const * const typestr{"SgExprListExp*"};
11384 static constexpr bool traverse{true};
11385 static constexpr auto mbr_ptr{&SgAssignedGotoStatement::p_targets};
11386 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11387 using bind = Desc<SgAssignedGotoStatement, SgExprListExp* SgAssignedGotoStatement::*, &SgAssignedGotoStatement::p_targets>;
11388};
11391 using base = SgStatement;
11392 static constexpr char const * const name{"AssignedGotoStatement"};
11393 static constexpr unsigned long variant{294};
11394 static constexpr bool concrete{true};
11395 using subclasses_t = mp::List<>;
11397};
11398template <> struct node_from_variant_t<294> { using type = SgAssignedGotoStatement; };
11399
11400// Class: AssociateStatement
11401template <> struct describe_field_t<SgAssociateStatement,SgDeclarationStatementPtrList,&SgAssociateStatement::p_associates> {
11403 using field_type = SgDeclarationStatementPtrList;
11404 static constexpr size_t position{0};
11405 static constexpr char const * const name{"associates"};
11406 static constexpr char const * const typestr{"SgDeclarationStatementPtrList"};
11407 static constexpr bool traverse{false};
11408 static constexpr auto mbr_ptr{&SgAssociateStatement::p_associates};
11409 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11410 using bind = Desc<SgAssociateStatement, SgDeclarationStatementPtrList SgAssociateStatement::*, &SgAssociateStatement::p_associates>;
11411};
11412template <> struct describe_field_t<SgAssociateStatement,SgBasicBlock*,&SgAssociateStatement::p_body> {
11414 using field_type = SgBasicBlock*;
11415 static constexpr size_t position{1};
11416 static constexpr char const * const name{"body"};
11417 static constexpr char const * const typestr{"SgBasicBlock*"};
11418 static constexpr bool traverse{true};
11419 static constexpr auto mbr_ptr{&SgAssociateStatement::p_body};
11420 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11421 using bind = Desc<SgAssociateStatement, SgBasicBlock* SgAssociateStatement::*, &SgAssociateStatement::p_body>;
11422};
11424 using node = SgAssociateStatement;
11425 using base = SgScopeStatement;
11426 static constexpr char const * const name{"AssociateStatement"};
11427 static constexpr unsigned long variant{295};
11428 static constexpr bool concrete{true};
11429 using subclasses_t = mp::List<>;
11431};
11432template <> struct node_from_variant_t<295> { using type = SgAssociateStatement; };
11433
11434// Class: AsteriskShapeExp
11436 using node = SgAsteriskShapeExp;
11437 using base = SgExpression;
11438 static constexpr char const * const name{"AsteriskShapeExp"};
11439 static constexpr unsigned long variant{296};
11440 static constexpr bool concrete{true};
11441 using subclasses_t = mp::List<>;
11442 using fields_t = mp::List<>;
11443};
11444template <> struct node_from_variant_t<296> { using type = SgAsteriskShapeExp; };
11445
11446// Class: AtOp
11447template <> struct describe_node_t<SgAtOp> {
11448 using node = SgAtOp;
11449 using base = SgBinaryOp;
11450 static constexpr char const * const name{"AtOp"};
11451 static constexpr unsigned long variant{297};
11452 static constexpr bool concrete{true};
11453 using subclasses_t = mp::List<>;
11454 using fields_t = mp::List<>;
11455};
11456template <> struct node_from_variant_t<297> { using type = SgAtOp; };
11457
11458// Class: Attribute
11459template <> struct describe_field_t<SgAttribute,std::string,&SgAttribute::p_name> {
11460 using parent = SgAttribute;
11461 using field_type = std::string;
11462 static constexpr size_t position{0};
11463 static constexpr char const * const name{"name"};
11464 static constexpr char const * const typestr{"std::string"};
11465 static constexpr bool traverse{false};
11466 static constexpr auto mbr_ptr{&SgAttribute::p_name};
11467 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11468 using bind = Desc<SgAttribute, std::string SgAttribute::*, &SgAttribute::p_name>;
11469};
11470template <> struct describe_node_t<SgAttribute> {
11471 using node = SgAttribute;
11472 using base = SgSupport;
11473 static constexpr char const * const name{"Attribute"};
11474 static constexpr unsigned long variant{298};
11475 static constexpr bool concrete{false};
11478};
11479template <> struct node_from_variant_t<298> { using type = SgAttribute; };
11480
11481// Class: AttributeSpecificationStatement
11482template <> struct describe_field_t<SgAttributeSpecificationStatement,SgStringList,&SgAttributeSpecificationStatement::p_name_list> {
11484 using field_type = SgStringList;
11485 static constexpr size_t position{0};
11486 static constexpr char const * const name{"name_list"};
11487 static constexpr char const * const typestr{"SgStringList"};
11488 static constexpr bool traverse{false};
11489 static constexpr auto mbr_ptr{&SgAttributeSpecificationStatement::p_name_list};
11490 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11491 using bind = Desc<SgAttributeSpecificationStatement, SgStringList SgAttributeSpecificationStatement::*, &SgAttributeSpecificationStatement::p_name_list>;
11492};
11493template <> struct describe_field_t<SgAttributeSpecificationStatement,SgAttributeSpecificationStatement::attribute_spec_enum,&SgAttributeSpecificationStatement::p_attribute_kind> {
11496 static constexpr size_t position{1};
11497 static constexpr char const * const name{"attribute_kind"};
11498 static constexpr char const * const typestr{"SgAttributeSpecificationStatement::attribute_spec_enum"};
11499 static constexpr bool traverse{false};
11500 static constexpr auto mbr_ptr{&SgAttributeSpecificationStatement::p_attribute_kind};
11501 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11502 using bind = Desc<SgAttributeSpecificationStatement, SgAttributeSpecificationStatement::attribute_spec_enum SgAttributeSpecificationStatement::*, &SgAttributeSpecificationStatement::p_attribute_kind>;
11503};
11504template <> struct describe_field_t<SgAttributeSpecificationStatement,int,&SgAttributeSpecificationStatement::p_intent> {
11506 using field_type = int;
11507 static constexpr size_t position{2};
11508 static constexpr char const * const name{"intent"};
11509 static constexpr char const * const typestr{"int"};
11510 static constexpr bool traverse{false};
11511 static constexpr auto mbr_ptr{&SgAttributeSpecificationStatement::p_intent};
11512 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11513 using bind = Desc<SgAttributeSpecificationStatement, int SgAttributeSpecificationStatement::*, &SgAttributeSpecificationStatement::p_intent>;
11514};
11515template <> struct describe_field_t<SgAttributeSpecificationStatement,SgExprListExp*,&SgAttributeSpecificationStatement::p_parameter_list> {
11517 using field_type = SgExprListExp*;
11518 static constexpr size_t position{3};
11519 static constexpr char const * const name{"parameter_list"};
11520 static constexpr char const * const typestr{"SgExprListExp*"};
11521 static constexpr bool traverse{false};
11522 static constexpr auto mbr_ptr{&SgAttributeSpecificationStatement::p_parameter_list};
11523 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11524 using bind = Desc<SgAttributeSpecificationStatement, SgExprListExp* SgAttributeSpecificationStatement::*, &SgAttributeSpecificationStatement::p_parameter_list>;
11525};
11526template <> struct describe_field_t<SgAttributeSpecificationStatement,SgDataStatementGroupPtrList,&SgAttributeSpecificationStatement::p_data_statement_group_list> {
11528 using field_type = SgDataStatementGroupPtrList;
11529 static constexpr size_t position{4};
11530 static constexpr char const * const name{"data_statement_group_list"};
11531 static constexpr char const * const typestr{"SgDataStatementGroupPtrList"};
11532 static constexpr bool traverse{false};
11533 static constexpr auto mbr_ptr{&SgAttributeSpecificationStatement::p_data_statement_group_list};
11534 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11535 using bind = Desc<SgAttributeSpecificationStatement, SgDataStatementGroupPtrList SgAttributeSpecificationStatement::*, &SgAttributeSpecificationStatement::p_data_statement_group_list>;
11536};
11537template <> struct describe_field_t<SgAttributeSpecificationStatement,SgExprListExp*,&SgAttributeSpecificationStatement::p_bind_list> {
11539 using field_type = SgExprListExp*;
11540 static constexpr size_t position{5};
11541 static constexpr char const * const name{"bind_list"};
11542 static constexpr char const * const typestr{"SgExprListExp*"};
11543 static constexpr bool traverse{false};
11544 static constexpr auto mbr_ptr{&SgAttributeSpecificationStatement::p_bind_list};
11545 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11546 using bind = Desc<SgAttributeSpecificationStatement, SgExprListExp* SgAttributeSpecificationStatement::*, &SgAttributeSpecificationStatement::p_bind_list>;
11547};
11548template <> struct describe_field_t<SgAttributeSpecificationStatement,SgDimensionObjectPtrList,&SgAttributeSpecificationStatement::p_dimension_object_list> {
11550 using field_type = SgDimensionObjectPtrList;
11551 static constexpr size_t position{6};
11552 static constexpr char const * const name{"dimension_object_list"};
11553 static constexpr char const * const typestr{"SgDimensionObjectPtrList"};
11554 static constexpr bool traverse{false};
11555 static constexpr auto mbr_ptr{&SgAttributeSpecificationStatement::p_dimension_object_list};
11556 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11557 using bind = Desc<SgAttributeSpecificationStatement, SgDimensionObjectPtrList SgAttributeSpecificationStatement::*, &SgAttributeSpecificationStatement::p_dimension_object_list>;
11558};
11568template <> struct node_from_variant_t<299> { using type = SgAttributeSpecificationStatement; };
11569
11570// Class: AutoType
11571template <> struct describe_node_t<SgAutoType> {
11572 using node = SgAutoType;
11573 using base = SgType;
11574 static constexpr char const * const name{"AutoType"};
11575 static constexpr unsigned long variant{300};
11576 static constexpr bool concrete{true};
11577 using subclasses_t = mp::List<>;
11578 using fields_t = mp::List<>;
11579};
11580template <> struct node_from_variant_t<300> { using type = SgAutoType; };
11581
11582// Class: AwaitExpression
11583template <> struct describe_field_t<SgAwaitExpression,SgExpression*,&SgAwaitExpression::p_value> {
11584 using parent = SgAwaitExpression;
11585 using field_type = SgExpression*;
11586 static constexpr size_t position{0};
11587 static constexpr char const * const name{"value"};
11588 static constexpr char const * const typestr{"SgExpression*"};
11589 static constexpr bool traverse{true};
11590 static constexpr auto mbr_ptr{&SgAwaitExpression::p_value};
11591 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11592 using bind = Desc<SgAwaitExpression, SgExpression* SgAwaitExpression::*, &SgAwaitExpression::p_value>;
11593};
11595 using node = SgAwaitExpression;
11596 using base = SgExpression;
11597 static constexpr char const * const name{"AwaitExpression"};
11598 static constexpr unsigned long variant{301};
11599 static constexpr bool concrete{true};
11600 using subclasses_t = mp::List<>;
11602};
11603template <> struct node_from_variant_t<301> { using type = SgAwaitExpression; };
11604
11605// Class: BackspaceStatement
11607 using node = SgBackspaceStatement;
11608 using base = SgIOStatement;
11609 static constexpr char const * const name{"BackspaceStatement"};
11610 static constexpr unsigned long variant{302};
11611 static constexpr bool concrete{true};
11612 using subclasses_t = mp::List<>;
11613 using fields_t = mp::List<>;
11614};
11615template <> struct node_from_variant_t<302> { using type = SgBackspaceStatement; };
11616
11617// Class: BaseClass
11618template <> struct describe_field_t<SgBaseClass,SgClassDeclaration*,&SgBaseClass::p_base_class> {
11619 using parent = SgBaseClass;
11621 static constexpr size_t position{0};
11622 static constexpr char const * const name{"base_class"};
11623 static constexpr char const * const typestr{"SgClassDeclaration*"};
11624 static constexpr bool traverse{true};
11625 static constexpr auto mbr_ptr{&SgBaseClass::p_base_class};
11626 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11627 using bind = Desc<SgBaseClass, SgClassDeclaration* SgBaseClass::*, &SgBaseClass::p_base_class>;
11628};
11629template <> struct describe_field_t<SgBaseClass,bool,&SgBaseClass::p_isDirectBaseClass> {
11630 using parent = SgBaseClass;
11631 using field_type = bool;
11632 static constexpr size_t position{1};
11633 static constexpr char const * const name{"isDirectBaseClass"};
11634 static constexpr char const * const typestr{"bool"};
11635 static constexpr bool traverse{false};
11636 static constexpr auto mbr_ptr{&SgBaseClass::p_isDirectBaseClass};
11637 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11638 using bind = Desc<SgBaseClass, bool SgBaseClass::*, &SgBaseClass::p_isDirectBaseClass>;
11639};
11640template <> struct describe_field_t<SgBaseClass,SgBaseClassModifier*,&SgBaseClass::p_baseClassModifier> {
11641 using parent = SgBaseClass;
11643 static constexpr size_t position{2};
11644 static constexpr char const * const name{"baseClassModifier"};
11645 static constexpr char const * const typestr{"SgBaseClassModifier*"};
11646 static constexpr bool traverse{false};
11647 static constexpr auto mbr_ptr{&SgBaseClass::p_baseClassModifier};
11648 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11649 using bind = Desc<SgBaseClass, SgBaseClassModifier* SgBaseClass::*, &SgBaseClass::p_baseClassModifier>;
11650};
11651template <> struct describe_field_t<SgBaseClass,int,&SgBaseClass::p_name_qualification_length> {
11652 using parent = SgBaseClass;
11653 using field_type = int;
11654 static constexpr size_t position{3};
11655 static constexpr char const * const name{"name_qualification_length"};
11656 static constexpr char const * const typestr{"int"};
11657 static constexpr bool traverse{false};
11658 static constexpr auto mbr_ptr{&SgBaseClass::p_name_qualification_length};
11659 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11660 using bind = Desc<SgBaseClass, int SgBaseClass::*, &SgBaseClass::p_name_qualification_length>;
11661};
11662template <> struct describe_field_t<SgBaseClass,bool,&SgBaseClass::p_type_elaboration_required> {
11663 using parent = SgBaseClass;
11664 using field_type = bool;
11665 static constexpr size_t position{4};
11666 static constexpr char const * const name{"type_elaboration_required"};
11667 static constexpr char const * const typestr{"bool"};
11668 static constexpr bool traverse{false};
11669 static constexpr auto mbr_ptr{&SgBaseClass::p_type_elaboration_required};
11670 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11671 using bind = Desc<SgBaseClass, bool SgBaseClass::*, &SgBaseClass::p_type_elaboration_required>;
11672};
11673template <> struct describe_field_t<SgBaseClass,bool,&SgBaseClass::p_global_qualification_required> {
11674 using parent = SgBaseClass;
11675 using field_type = bool;
11676 static constexpr size_t position{5};
11677 static constexpr char const * const name{"global_qualification_required"};
11678 static constexpr char const * const typestr{"bool"};
11679 static constexpr bool traverse{false};
11680 static constexpr auto mbr_ptr{&SgBaseClass::p_global_qualification_required};
11681 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11682 using bind = Desc<SgBaseClass, bool SgBaseClass::*, &SgBaseClass::p_global_qualification_required>;
11683};
11693template <> struct node_from_variant_t<303> { using type = SgBaseClass; };
11694
11695// Class: ExpBaseClass
11696template <> struct describe_field_t<SgExpBaseClass,SgExpression*,&SgExpBaseClass::p_base_class_exp> {
11697 using parent = SgExpBaseClass;
11698 using field_type = SgExpression*;
11699 static constexpr size_t position{0};
11700 static constexpr char const * const name{"base_class_exp"};
11701 static constexpr char const * const typestr{"SgExpression*"};
11702 static constexpr bool traverse{true};
11703 static constexpr auto mbr_ptr{&SgExpBaseClass::p_base_class_exp};
11704 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11705 using bind = Desc<SgExpBaseClass, SgExpression* SgExpBaseClass::*, &SgExpBaseClass::p_base_class_exp>;
11706};
11707template <> struct describe_node_t<SgExpBaseClass> {
11708 using node = SgExpBaseClass;
11709 using base = SgBaseClass;
11710 static constexpr char const * const name{"ExpBaseClass"};
11711 static constexpr unsigned long variant{304};
11712 static constexpr bool concrete{true};
11713 using subclasses_t = mp::List<>;
11715};
11716template <> struct node_from_variant_t<304> { using type = SgExpBaseClass; };
11717
11718// Class: BaseClassModifier
11719template <> struct describe_field_t<SgBaseClassModifier,SgBaseClassModifier::baseclass_modifier_enum,&SgBaseClassModifier::p_modifier> {
11722 static constexpr size_t position{0};
11723 static constexpr char const * const name{"modifier"};
11724 static constexpr char const * const typestr{"SgBaseClassModifier::baseclass_modifier_enum"};
11725 static constexpr bool traverse{false};
11726 static constexpr auto mbr_ptr{&SgBaseClassModifier::p_modifier};
11727 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11728 using bind = Desc<SgBaseClassModifier, SgBaseClassModifier::baseclass_modifier_enum SgBaseClassModifier::*, &SgBaseClassModifier::p_modifier>;
11729};
11730template <> struct describe_field_t<SgBaseClassModifier,SgAccessModifier,&SgBaseClassModifier::p_accessModifier> {
11733 static constexpr size_t position{1};
11734 static constexpr char const * const name{"accessModifier"};
11735 static constexpr char const * const typestr{"SgAccessModifier"};
11736 static constexpr bool traverse{false};
11737 static constexpr auto mbr_ptr{&SgBaseClassModifier::p_accessModifier};
11738 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11739 using bind = Desc<SgBaseClassModifier, SgAccessModifier SgBaseClassModifier::*, &SgBaseClassModifier::p_accessModifier>;
11740};
11742 using node = SgBaseClassModifier;
11743 using base = SgModifier;
11744 static constexpr char const * const name{"BaseClassModifier"};
11745 static constexpr unsigned long variant{305};
11746 static constexpr bool concrete{true};
11747 using subclasses_t = mp::List<>;
11749};
11750template <> struct node_from_variant_t<305> { using type = SgBaseClassModifier; };
11751
11752// Class: BasicBlock
11753template <> struct describe_field_t<SgBasicBlock,SgStatementPtrList,&SgBasicBlock::p_statements> {
11754 using parent = SgBasicBlock;
11755 using field_type = SgStatementPtrList;
11756 static constexpr size_t position{0};
11757 static constexpr char const * const name{"statements"};
11758 static constexpr char const * const typestr{"SgStatementPtrList"};
11759 static constexpr bool traverse{true};
11760 static constexpr auto mbr_ptr{&SgBasicBlock::p_statements};
11761 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11762 using bind = Desc<SgBasicBlock, SgStatementPtrList SgBasicBlock::*, &SgBasicBlock::p_statements>;
11763};
11764template <> struct describe_field_t<SgBasicBlock,std::string,&SgBasicBlock::p_asm_function_body> {
11765 using parent = SgBasicBlock;
11766 using field_type = std::string;
11767 static constexpr size_t position{1};
11768 static constexpr char const * const name{"asm_function_body"};
11769 static constexpr char const * const typestr{"std::string"};
11770 static constexpr bool traverse{false};
11771 static constexpr auto mbr_ptr{&SgBasicBlock::p_asm_function_body};
11772 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11773 using bind = Desc<SgBasicBlock, std::string SgBasicBlock::*, &SgBasicBlock::p_asm_function_body>;
11774};
11775template <> struct describe_field_t<SgBasicBlock,std::string,&SgBasicBlock::p_string_label> {
11776 using parent = SgBasicBlock;
11777 using field_type = std::string;
11778 static constexpr size_t position{2};
11779 static constexpr char const * const name{"string_label"};
11780 static constexpr char const * const typestr{"std::string"};
11781 static constexpr bool traverse{false};
11782 static constexpr auto mbr_ptr{&SgBasicBlock::p_string_label};
11783 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11784 using bind = Desc<SgBasicBlock, std::string SgBasicBlock::*, &SgBasicBlock::p_string_label>;
11785};
11786template <> struct describe_node_t<SgBasicBlock> {
11787 using node = SgBasicBlock;
11788 using base = SgScopeStatement;
11789 static constexpr char const * const name{"BasicBlock"};
11790 static constexpr unsigned long variant{306};
11791 static constexpr bool concrete{true};
11792 using subclasses_t = mp::List<>;
11794};
11795template <> struct node_from_variant_t<306> { using type = SgBasicBlock; };
11796
11797// Class: BidirectionalGraph
11799 using node = SgBidirectionalGraph;
11801 static constexpr char const * const name{"BidirectionalGraph"};
11802 static constexpr unsigned long variant{307};
11803 static constexpr bool concrete{false};
11805 using fields_t = mp::List<>;
11806};
11807template <> struct node_from_variant_t<307> { using type = SgBidirectionalGraph; };
11808
11809// Class: BinaryComposite
11810template <> struct describe_field_t<SgBinaryComposite,SgAsmGenericFileList*,&SgBinaryComposite::p_genericFileList> {
11811 using parent = SgBinaryComposite;
11813 static constexpr size_t position{0};
11814 static constexpr char const * const name{"genericFileList"};
11815 static constexpr char const * const typestr{"SgAsmGenericFileList*"};
11816 static constexpr bool traverse{true};
11817 static constexpr auto mbr_ptr{&SgBinaryComposite::p_genericFileList};
11818 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11819 using bind = Desc<SgBinaryComposite, SgAsmGenericFileList* SgBinaryComposite::*, &SgBinaryComposite::p_genericFileList>;
11820};
11821template <> struct describe_field_t<SgBinaryComposite,SgAsmInterpretationList*,&SgBinaryComposite::p_interpretations> {
11822 using parent = SgBinaryComposite;
11824 static constexpr size_t position{1};
11825 static constexpr char const * const name{"interpretations"};
11826 static constexpr char const * const typestr{"SgAsmInterpretationList*"};
11827 static constexpr bool traverse{true};
11828 static constexpr auto mbr_ptr{&SgBinaryComposite::p_interpretations};
11829 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11830 using bind = Desc<SgBinaryComposite, SgAsmInterpretationList* SgBinaryComposite::*, &SgBinaryComposite::p_interpretations>;
11831};
11833 using node = SgBinaryComposite;
11834 using base = SgFile;
11835 static constexpr char const * const name{"BinaryComposite"};
11836 static constexpr unsigned long variant{308};
11837 static constexpr bool concrete{true};
11840};
11841template <> struct node_from_variant_t<308> { using type = SgBinaryComposite; };
11842
11843// Class: BinaryOp
11845 using parent = SgBinaryOp;
11846 using field_type = SgExpression*;
11847 static constexpr size_t position{0};
11848 static constexpr char const * const name{"lhs_operand_i"};
11849 static constexpr char const * const typestr{"SgExpression*"};
11850 static constexpr bool traverse{true};
11851 static constexpr auto mbr_ptr{&SgBinaryOp::p_lhs_operand_i};
11852 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11853 using bind = Desc<SgBinaryOp, SgExpression* SgBinaryOp::*, &SgBinaryOp::p_lhs_operand_i>;
11854};
11856 using parent = SgBinaryOp;
11857 using field_type = SgExpression*;
11858 static constexpr size_t position{1};
11859 static constexpr char const * const name{"rhs_operand_i"};
11860 static constexpr char const * const typestr{"SgExpression*"};
11861 static constexpr bool traverse{true};
11862 static constexpr auto mbr_ptr{&SgBinaryOp::p_rhs_operand_i};
11863 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11864 using bind = Desc<SgBinaryOp, SgExpression* SgBinaryOp::*, &SgBinaryOp::p_rhs_operand_i>;
11865};
11867 using parent = SgBinaryOp;
11868 using field_type = SgType*;
11869 static constexpr size_t position{2};
11870 static constexpr char const * const name{"expression_type"};
11871 static constexpr char const * const typestr{"SgType*"};
11872 static constexpr bool traverse{false};
11873 static constexpr auto mbr_ptr{&SgBinaryOp::p_expression_type};
11874 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11875 using bind = Desc<SgBinaryOp, SgType* SgBinaryOp::*, &SgBinaryOp::p_expression_type>;
11876};
11877template <> struct describe_field_t<SgBinaryOp,SgExpression*,&SgBinaryOp::p_originalExpressionTree> {
11878 using parent = SgBinaryOp;
11879 using field_type = SgExpression*;
11880 static constexpr size_t position{3};
11881 static constexpr char const * const name{"originalExpressionTree"};
11882 static constexpr char const * const typestr{"SgExpression*"};
11883 static constexpr bool traverse{false};
11884 static constexpr auto mbr_ptr{&SgBinaryOp::p_originalExpressionTree};
11885 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11886 using bind = Desc<SgBinaryOp, SgExpression* SgBinaryOp::*, &SgBinaryOp::p_originalExpressionTree>;
11887};
11897template <> struct node_from_variant_t<309> { using type = SgBinaryOp; };
11898
11899// Class: BitAndOp
11900template <> struct describe_node_t<SgBitAndOp> {
11901 using node = SgBitAndOp;
11902 using base = SgBinaryOp;
11903 static constexpr char const * const name{"BitAndOp"};
11904 static constexpr unsigned long variant{310};
11905 static constexpr bool concrete{true};
11906 using subclasses_t = mp::List<>;
11907 using fields_t = mp::List<>;
11908};
11909template <> struct node_from_variant_t<310> { using type = SgBitAndOp; };
11910
11911// Class: BitAttribute
11912template <> struct describe_field_t<SgBitAttribute,unsigned long int,&SgBitAttribute::p_bitflag> {
11913 using parent = SgBitAttribute;
11914 using field_type = unsigned long int;
11915 static constexpr size_t position{0};
11916 static constexpr char const * const name{"bitflag"};
11917 static constexpr char const * const typestr{"unsigned long int"};
11918 static constexpr bool traverse{false};
11919 static constexpr auto mbr_ptr{&SgBitAttribute::p_bitflag};
11920 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11921 using bind = Desc<SgBitAttribute, unsigned long int SgBitAttribute::*, &SgBitAttribute::p_bitflag>;
11922};
11923template <> struct describe_node_t<SgBitAttribute> {
11924 using node = SgBitAttribute;
11925 using base = SgAttribute;
11926 static constexpr char const * const name{"BitAttribute"};
11927 static constexpr unsigned long variant{311};
11928 static constexpr bool concrete{false};
11931};
11932template <> struct node_from_variant_t<311> { using type = SgBitAttribute; };
11933
11934// Class: BitComplementOp
11936 using node = SgBitComplementOp;
11937 using base = SgUnaryOp;
11938 static constexpr char const * const name{"BitComplementOp"};
11939 static constexpr unsigned long variant{312};
11940 static constexpr bool concrete{true};
11941 using subclasses_t = mp::List<>;
11942 using fields_t = mp::List<>;
11943};
11944template <> struct node_from_variant_t<312> { using type = SgBitComplementOp; };
11945
11946// Class: BitEqvOp
11947template <> struct describe_node_t<SgBitEqvOp> {
11948 using node = SgBitEqvOp;
11949 using base = SgBinaryOp;
11950 static constexpr char const * const name{"BitEqvOp"};
11951 static constexpr unsigned long variant{313};
11952 static constexpr bool concrete{true};
11953 using subclasses_t = mp::List<>;
11954 using fields_t = mp::List<>;
11955};
11956template <> struct node_from_variant_t<313> { using type = SgBitEqvOp; };
11957
11958// Class: BitOrOp
11959template <> struct describe_node_t<SgBitOrOp> {
11960 using node = SgBitOrOp;
11961 using base = SgBinaryOp;
11962 static constexpr char const * const name{"BitOrOp"};
11963 static constexpr unsigned long variant{314};
11964 static constexpr bool concrete{true};
11965 using subclasses_t = mp::List<>;
11966 using fields_t = mp::List<>;
11967};
11968template <> struct node_from_variant_t<314> { using type = SgBitOrOp; };
11969
11970// Class: BitXorOp
11971template <> struct describe_node_t<SgBitXorOp> {
11972 using node = SgBitXorOp;
11973 using base = SgBinaryOp;
11974 static constexpr char const * const name{"BitXorOp"};
11975 static constexpr unsigned long variant{315};
11976 static constexpr bool concrete{true};
11977 using subclasses_t = mp::List<>;
11978 using fields_t = mp::List<>;
11979};
11980template <> struct node_from_variant_t<315> { using type = SgBitXorOp; };
11981
11982// Class: BlockDataStatement
11983template <> struct describe_field_t<SgBlockDataStatement,SgBasicBlock*,&SgBlockDataStatement::p_body> {
11985 using field_type = SgBasicBlock*;
11986 static constexpr size_t position{0};
11987 static constexpr char const * const name{"body"};
11988 static constexpr char const * const typestr{"SgBasicBlock*"};
11989 static constexpr bool traverse{false};
11990 static constexpr auto mbr_ptr{&SgBlockDataStatement::p_body};
11991 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
11992 using bind = Desc<SgBlockDataStatement, SgBasicBlock* SgBlockDataStatement::*, &SgBlockDataStatement::p_body>;
11993};
11995 using node = SgBlockDataStatement;
11996 using base = SgScopeStatement;
11997 static constexpr char const * const name{"BlockDataStatement"};
11998 static constexpr unsigned long variant{316};
11999 static constexpr bool concrete{true};
12000 using subclasses_t = mp::List<>;
12002};
12003template <> struct node_from_variant_t<316> { using type = SgBlockDataStatement; };
12004
12005// Class: BoolValExp
12007 using parent = SgBoolValExp;
12008 using field_type = int;
12009 static constexpr size_t position{0};
12010 static constexpr char const * const name{"value"};
12011 static constexpr char const * const typestr{"int"};
12012 static constexpr bool traverse{false};
12013 static constexpr auto mbr_ptr{&SgBoolValExp::p_value};
12014 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12015 using bind = Desc<SgBoolValExp, int SgBoolValExp::*, &SgBoolValExp::p_value>;
12016};
12017template <> struct describe_node_t<SgBoolValExp> {
12018 using node = SgBoolValExp;
12019 using base = SgValueExp;
12020 static constexpr char const * const name{"BoolValExp"};
12021 static constexpr unsigned long variant{317};
12022 static constexpr bool concrete{true};
12023 using subclasses_t = mp::List<>;
12025};
12026template <> struct node_from_variant_t<317> { using type = SgBoolValExp; };
12027
12028// Class: BreakStmt
12029template <> struct describe_field_t<SgBreakStmt,std::string,&SgBreakStmt::p_do_string_label> {
12030 using parent = SgBreakStmt;
12031 using field_type = std::string;
12032 static constexpr size_t position{0};
12033 static constexpr char const * const name{"do_string_label"};
12034 static constexpr char const * const typestr{"std::string"};
12035 static constexpr bool traverse{false};
12036 static constexpr auto mbr_ptr{&SgBreakStmt::p_do_string_label};
12037 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12038 using bind = Desc<SgBreakStmt, std::string SgBreakStmt::*, &SgBreakStmt::p_do_string_label>;
12039};
12040template <> struct describe_node_t<SgBreakStmt> {
12041 using node = SgBreakStmt;
12042 using base = SgStatement;
12043 static constexpr char const * const name{"BreakStmt"};
12044 static constexpr unsigned long variant{318};
12045 static constexpr bool concrete{true};
12046 using subclasses_t = mp::List<>;
12048};
12049template <> struct node_from_variant_t<318> { using type = SgBreakStmt; };
12050
12051// Class: BracedInitializer
12052template <> struct describe_field_t<SgBracedInitializer,SgExprListExp*,&SgBracedInitializer::p_initializers> {
12054 using field_type = SgExprListExp*;
12055 static constexpr size_t position{0};
12056 static constexpr char const * const name{"initializers"};
12057 static constexpr char const * const typestr{"SgExprListExp*"};
12058 static constexpr bool traverse{true};
12059 static constexpr auto mbr_ptr{&SgBracedInitializer::p_initializers};
12060 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12061 using bind = Desc<SgBracedInitializer, SgExprListExp* SgBracedInitializer::*, &SgBracedInitializer::p_initializers>;
12062};
12063template <> struct describe_field_t<SgBracedInitializer,SgType*,&SgBracedInitializer::p_expression_type> {
12065 using field_type = SgType*;
12066 static constexpr size_t position{1};
12067 static constexpr char const * const name{"expression_type"};
12068 static constexpr char const * const typestr{"SgType*"};
12069 static constexpr bool traverse{false};
12070 static constexpr auto mbr_ptr{&SgBracedInitializer::p_expression_type};
12071 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12072 using bind = Desc<SgBracedInitializer, SgType* SgBracedInitializer::*, &SgBracedInitializer::p_expression_type>;
12073};
12075 using node = SgBracedInitializer;
12076 using base = SgInitializer;
12077 static constexpr char const * const name{"BracedInitializer"};
12078 static constexpr unsigned long variant{319};
12079 static constexpr bool concrete{true};
12080 using subclasses_t = mp::List<>;
12082};
12083template <> struct node_from_variant_t<319> { using type = SgBracedInitializer; };
12084
12085// Class: C_PreprocessorDirectiveStatement
12086template <> struct describe_field_t<SgC_PreprocessorDirectiveStatement,std::string,&SgC_PreprocessorDirectiveStatement::p_directiveString> {
12088 using field_type = std::string;
12089 static constexpr size_t position{0};
12090 static constexpr char const * const name{"directiveString"};
12091 static constexpr char const * const typestr{"std::string"};
12092 static constexpr bool traverse{false};
12093 static constexpr auto mbr_ptr{&SgC_PreprocessorDirectiveStatement::p_directiveString};
12094 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12095 using bind = Desc<SgC_PreprocessorDirectiveStatement, std::string SgC_PreprocessorDirectiveStatement::*, &SgC_PreprocessorDirectiveStatement::p_directiveString>;
12096};
12106template <> struct node_from_variant_t<320> { using type = SgC_PreprocessorDirectiveStatement; };
12107
12108// Class: CaseOptionStmt
12109template <> struct describe_field_t<SgCaseOptionStmt,SgExpression*,&SgCaseOptionStmt::p_key> {
12110 using parent = SgCaseOptionStmt;
12111 using field_type = SgExpression*;
12112 static constexpr size_t position{0};
12113 static constexpr char const * const name{"key"};
12114 static constexpr char const * const typestr{"SgExpression*"};
12115 static constexpr bool traverse{true};
12116 static constexpr auto mbr_ptr{&SgCaseOptionStmt::p_key};
12117 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12118 using bind = Desc<SgCaseOptionStmt, SgExpression* SgCaseOptionStmt::*, &SgCaseOptionStmt::p_key>;
12119};
12121 using parent = SgCaseOptionStmt;
12122 using field_type = SgStatement*;
12123 static constexpr size_t position{1};
12124 static constexpr char const * const name{"body"};
12125 static constexpr char const * const typestr{"SgStatement*"};
12126 static constexpr bool traverse{true};
12127 static constexpr auto mbr_ptr{&SgCaseOptionStmt::p_body};
12128 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12129 using bind = Desc<SgCaseOptionStmt, SgStatement* SgCaseOptionStmt::*, &SgCaseOptionStmt::p_body>;
12130};
12132 using parent = SgCaseOptionStmt;
12133 using field_type = SgExpression*;
12134 static constexpr size_t position{2};
12135 static constexpr char const * const name{"key_range_end"};
12136 static constexpr char const * const typestr{"SgExpression*"};
12137 static constexpr bool traverse{true};
12138 static constexpr auto mbr_ptr{&SgCaseOptionStmt::p_key_range_end};
12139 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12140 using bind = Desc<SgCaseOptionStmt, SgExpression* SgCaseOptionStmt::*, &SgCaseOptionStmt::p_key_range_end>;
12141};
12142template <> struct describe_field_t<SgCaseOptionStmt,std::string,&SgCaseOptionStmt::p_case_construct_name> {
12143 using parent = SgCaseOptionStmt;
12144 using field_type = std::string;
12145 static constexpr size_t position{3};
12146 static constexpr char const * const name{"case_construct_name"};
12147 static constexpr char const * const typestr{"std::string"};
12148 static constexpr bool traverse{false};
12149 static constexpr auto mbr_ptr{&SgCaseOptionStmt::p_case_construct_name};
12150 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12151 using bind = Desc<SgCaseOptionStmt, std::string SgCaseOptionStmt::*, &SgCaseOptionStmt::p_case_construct_name>;
12152};
12153template <> struct describe_field_t<SgCaseOptionStmt,bool,&SgCaseOptionStmt::p_has_fall_through> {
12154 using parent = SgCaseOptionStmt;
12155 using field_type = bool;
12156 static constexpr size_t position{4};
12157 static constexpr char const * const name{"has_fall_through"};
12158 static constexpr char const * const typestr{"bool"};
12159 static constexpr bool traverse{false};
12160 static constexpr auto mbr_ptr{&SgCaseOptionStmt::p_has_fall_through};
12161 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12162 using bind = Desc<SgCaseOptionStmt, bool SgCaseOptionStmt::*, &SgCaseOptionStmt::p_has_fall_through>;
12163};
12173template <> struct node_from_variant_t<321> { using type = SgCaseOptionStmt; };
12174
12175// Class: CastExp
12176template <> struct describe_field_t<SgCastExp,SgCastExp::cast_type_enum,&SgCastExp::p_cast_type> {
12177 using parent = SgCastExp;
12179 static constexpr size_t position{0};
12180 static constexpr char const * const name{"cast_type"};
12181 static constexpr char const * const typestr{"SgCastExp::cast_type_enum"};
12182 static constexpr bool traverse{false};
12183 static constexpr auto mbr_ptr{&SgCastExp::p_cast_type};
12184 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12185 using bind = Desc<SgCastExp, SgCastExp::cast_type_enum SgCastExp::*, &SgCastExp::p_cast_type>;
12186};
12187template <> struct describe_field_t<SgCastExp,SgExpression*,&SgCastExp::p_originalExpressionTree> {
12188 using parent = SgCastExp;
12189 using field_type = SgExpression*;
12190 static constexpr size_t position{1};
12191 static constexpr char const * const name{"originalExpressionTree"};
12192 static constexpr char const * const typestr{"SgExpression*"};
12193 static constexpr bool traverse{false};
12194 static constexpr auto mbr_ptr{&SgCastExp::p_originalExpressionTree};
12195 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12196 using bind = Desc<SgCastExp, SgExpression* SgCastExp::*, &SgCastExp::p_originalExpressionTree>;
12197};
12198template <> struct describe_field_t<SgCastExp,int,&SgCastExp::p_name_qualification_length> {
12199 using parent = SgCastExp;
12200 using field_type = int;
12201 static constexpr size_t position{2};
12202 static constexpr char const * const name{"name_qualification_length"};
12203 static constexpr char const * const typestr{"int"};
12204 static constexpr bool traverse{false};
12205 static constexpr auto mbr_ptr{&SgCastExp::p_name_qualification_length};
12206 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12207 using bind = Desc<SgCastExp, int SgCastExp::*, &SgCastExp::p_name_qualification_length>;
12208};
12209template <> struct describe_field_t<SgCastExp,bool,&SgCastExp::p_type_elaboration_required> {
12210 using parent = SgCastExp;
12211 using field_type = bool;
12212 static constexpr size_t position{3};
12213 static constexpr char const * const name{"type_elaboration_required"};
12214 static constexpr char const * const typestr{"bool"};
12215 static constexpr bool traverse{false};
12216 static constexpr auto mbr_ptr{&SgCastExp::p_type_elaboration_required};
12217 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12218 using bind = Desc<SgCastExp, bool SgCastExp::*, &SgCastExp::p_type_elaboration_required>;
12219};
12220template <> struct describe_field_t<SgCastExp,bool,&SgCastExp::p_global_qualification_required> {
12221 using parent = SgCastExp;
12222 using field_type = bool;
12223 static constexpr size_t position{4};
12224 static constexpr char const * const name{"global_qualification_required"};
12225 static constexpr char const * const typestr{"bool"};
12226 static constexpr bool traverse{false};
12227 static constexpr auto mbr_ptr{&SgCastExp::p_global_qualification_required};
12228 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12229 using bind = Desc<SgCastExp, bool SgCastExp::*, &SgCastExp::p_global_qualification_required>;
12230};
12231template <> struct describe_field_t<SgCastExp,bool,&SgCastExp::p_castContainsBaseTypeDefiningDeclaration> {
12232 using parent = SgCastExp;
12233 using field_type = bool;
12234 static constexpr size_t position{5};
12235 static constexpr char const * const name{"castContainsBaseTypeDefiningDeclaration"};
12236 static constexpr char const * const typestr{"bool"};
12237 static constexpr bool traverse{false};
12238 static constexpr auto mbr_ptr{&SgCastExp::p_castContainsBaseTypeDefiningDeclaration};
12239 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12240 using bind = Desc<SgCastExp, bool SgCastExp::*, &SgCastExp::p_castContainsBaseTypeDefiningDeclaration>;
12241};
12242template <> struct describe_field_t<SgCastExp,int,&SgCastExp::p_name_qualification_for_pointer_to_member_class_length> {
12243 using parent = SgCastExp;
12244 using field_type = int;
12245 static constexpr size_t position{6};
12246 static constexpr char const * const name{"name_qualification_for_pointer_to_member_class_length"};
12247 static constexpr char const * const typestr{"int"};
12248 static constexpr bool traverse{false};
12249 static constexpr auto mbr_ptr{&SgCastExp::p_name_qualification_for_pointer_to_member_class_length};
12250 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12251 using bind = Desc<SgCastExp, int SgCastExp::*, &SgCastExp::p_name_qualification_for_pointer_to_member_class_length>;
12252};
12253template <> struct describe_field_t<SgCastExp,bool,&SgCastExp::p_type_elaboration_for_pointer_to_member_class_required> {
12254 using parent = SgCastExp;
12255 using field_type = bool;
12256 static constexpr size_t position{7};
12257 static constexpr char const * const name{"type_elaboration_for_pointer_to_member_class_required"};
12258 static constexpr char const * const typestr{"bool"};
12259 static constexpr bool traverse{false};
12260 static constexpr auto mbr_ptr{&SgCastExp::p_type_elaboration_for_pointer_to_member_class_required};
12261 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12262 using bind = Desc<SgCastExp, bool SgCastExp::*, &SgCastExp::p_type_elaboration_for_pointer_to_member_class_required>;
12263};
12264template <> struct describe_field_t<SgCastExp,bool,&SgCastExp::p_global_qualification_for_pointer_to_member_class_required> {
12265 using parent = SgCastExp;
12266 using field_type = bool;
12267 static constexpr size_t position{8};
12268 static constexpr char const * const name{"global_qualification_for_pointer_to_member_class_required"};
12269 static constexpr char const * const typestr{"bool"};
12270 static constexpr bool traverse{false};
12271 static constexpr auto mbr_ptr{&SgCastExp::p_global_qualification_for_pointer_to_member_class_required};
12272 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12273 using bind = Desc<SgCastExp, bool SgCastExp::*, &SgCastExp::p_global_qualification_for_pointer_to_member_class_required>;
12274};
12284template <> struct node_from_variant_t<322> { using type = SgCastExp; };
12285
12286// Class: CatchOptionStmt
12288 using parent = SgCatchOptionStmt;
12290 static constexpr size_t position{0};
12291 static constexpr char const * const name{"condition"};
12292 static constexpr char const * const typestr{"SgVariableDeclaration*"};
12293 static constexpr bool traverse{true};
12294 static constexpr auto mbr_ptr{&SgCatchOptionStmt::p_condition};
12295 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12296 using bind = Desc<SgCatchOptionStmt, SgVariableDeclaration* SgCatchOptionStmt::*, &SgCatchOptionStmt::p_condition>;
12297};
12299 using parent = SgCatchOptionStmt;
12300 using field_type = SgStatement*;
12301 static constexpr size_t position{1};
12302 static constexpr char const * const name{"body"};
12303 static constexpr char const * const typestr{"SgStatement*"};
12304 static constexpr bool traverse{true};
12305 static constexpr auto mbr_ptr{&SgCatchOptionStmt::p_body};
12306 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12307 using bind = Desc<SgCatchOptionStmt, SgStatement* SgCatchOptionStmt::*, &SgCatchOptionStmt::p_body>;
12308};
12310 using parent = SgCatchOptionStmt;
12311 using field_type = SgTryStmt*;
12312 static constexpr size_t position{2};
12313 static constexpr char const * const name{"trystmt"};
12314 static constexpr char const * const typestr{"SgTryStmt*"};
12315 static constexpr bool traverse{false};
12316 static constexpr auto mbr_ptr{&SgCatchOptionStmt::p_trystmt};
12317 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12318 using bind = Desc<SgCatchOptionStmt, SgTryStmt* SgCatchOptionStmt::*, &SgCatchOptionStmt::p_trystmt>;
12319};
12321 using node = SgCatchOptionStmt;
12322 using base = SgScopeStatement;
12323 static constexpr char const * const name{"CatchOptionStmt"};
12324 static constexpr unsigned long variant{323};
12325 static constexpr bool concrete{true};
12326 using subclasses_t = mp::List<>;
12328};
12329template <> struct node_from_variant_t<323> { using type = SgCatchOptionStmt; };
12330
12331// Class: CatchStatementSeq
12334 using field_type = SgStatementPtrList;
12335 static constexpr size_t position{0};
12336 static constexpr char const * const name{"catch_statement_seq"};
12337 static constexpr char const * const typestr{"SgStatementPtrList"};
12338 static constexpr bool traverse{true};
12339 static constexpr auto mbr_ptr{&SgCatchStatementSeq::p_catch_statement_seq};
12340 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12341 using bind = Desc<SgCatchStatementSeq, SgStatementPtrList SgCatchStatementSeq::*, &SgCatchStatementSeq::p_catch_statement_seq>;
12342};
12344 using node = SgCatchStatementSeq;
12345 using base = SgStatement;
12346 static constexpr char const * const name{"CatchStatementSeq"};
12347 static constexpr unsigned long variant{324};
12348 static constexpr bool concrete{true};
12349 using subclasses_t = mp::List<>;
12351};
12352template <> struct node_from_variant_t<324> { using type = SgCatchStatementSeq; };
12353
12354// Class: CharVal
12355template <> struct describe_field_t<SgCharVal,char,&SgCharVal::p_value> {
12356 using parent = SgCharVal;
12357 using field_type = char;
12358 static constexpr size_t position{0};
12359 static constexpr char const * const name{"value"};
12360 static constexpr char const * const typestr{"char"};
12361 static constexpr bool traverse{false};
12362 static constexpr auto mbr_ptr{&SgCharVal::p_value};
12363 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12364 using bind = Desc<SgCharVal, char SgCharVal::*, &SgCharVal::p_value>;
12365};
12366template <> struct describe_field_t<SgCharVal,std::string,&SgCharVal::p_valueString> {
12367 using parent = SgCharVal;
12368 using field_type = std::string;
12369 static constexpr size_t position{1};
12370 static constexpr char const * const name{"valueString"};
12371 static constexpr char const * const typestr{"std::string"};
12372 static constexpr bool traverse{false};
12373 static constexpr auto mbr_ptr{&SgCharVal::p_valueString};
12374 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12375 using bind = Desc<SgCharVal, std::string SgCharVal::*, &SgCharVal::p_valueString>;
12376};
12377template <> struct describe_node_t<SgCharVal> {
12378 using node = SgCharVal;
12379 using base = SgValueExp;
12380 static constexpr char const * const name{"CharVal"};
12381 static constexpr unsigned long variant{325};
12382 static constexpr bool concrete{true};
12383 using subclasses_t = mp::List<>;
12385};
12386template <> struct node_from_variant_t<325> { using type = SgCharVal; };
12387
12388// Class: Char16Val
12389template <> struct describe_field_t<SgChar16Val,unsigned short,&SgChar16Val::p_valueUL> {
12390 using parent = SgChar16Val;
12391 using field_type = unsigned short;
12392 static constexpr size_t position{0};
12393 static constexpr char const * const name{"valueUL"};
12394 static constexpr char const * const typestr{"unsigned short"};
12395 static constexpr bool traverse{false};
12396 static constexpr auto mbr_ptr{&SgChar16Val::p_valueUL};
12397 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12398 using bind = Desc<SgChar16Val, unsigned short SgChar16Val::*, &SgChar16Val::p_valueUL>;
12399};
12400template <> struct describe_field_t<SgChar16Val,std::string,&SgChar16Val::p_valueString> {
12401 using parent = SgChar16Val;
12402 using field_type = std::string;
12403 static constexpr size_t position{1};
12404 static constexpr char const * const name{"valueString"};
12405 static constexpr char const * const typestr{"std::string"};
12406 static constexpr bool traverse{false};
12407 static constexpr auto mbr_ptr{&SgChar16Val::p_valueString};
12408 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12409 using bind = Desc<SgChar16Val, std::string SgChar16Val::*, &SgChar16Val::p_valueString>;
12410};
12411template <> struct describe_node_t<SgChar16Val> {
12412 using node = SgChar16Val;
12413 using base = SgValueExp;
12414 static constexpr char const * const name{"Char16Val"};
12415 static constexpr unsigned long variant{326};
12416 static constexpr bool concrete{true};
12417 using subclasses_t = mp::List<>;
12419};
12420template <> struct node_from_variant_t<326> { using type = SgChar16Val; };
12421
12422// Class: Char32Val
12423template <> struct describe_field_t<SgChar32Val,unsigned int,&SgChar32Val::p_valueUL> {
12424 using parent = SgChar32Val;
12425 using field_type = unsigned int;
12426 static constexpr size_t position{0};
12427 static constexpr char const * const name{"valueUL"};
12428 static constexpr char const * const typestr{"unsigned int"};
12429 static constexpr bool traverse{false};
12430 static constexpr auto mbr_ptr{&SgChar32Val::p_valueUL};
12431 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12432 using bind = Desc<SgChar32Val, unsigned int SgChar32Val::*, &SgChar32Val::p_valueUL>;
12433};
12434template <> struct describe_field_t<SgChar32Val,std::string,&SgChar32Val::p_valueString> {
12435 using parent = SgChar32Val;
12436 using field_type = std::string;
12437 static constexpr size_t position{1};
12438 static constexpr char const * const name{"valueString"};
12439 static constexpr char const * const typestr{"std::string"};
12440 static constexpr bool traverse{false};
12441 static constexpr auto mbr_ptr{&SgChar32Val::p_valueString};
12442 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12443 using bind = Desc<SgChar32Val, std::string SgChar32Val::*, &SgChar32Val::p_valueString>;
12444};
12445template <> struct describe_node_t<SgChar32Val> {
12446 using node = SgChar32Val;
12447 using base = SgValueExp;
12448 static constexpr char const * const name{"Char32Val"};
12449 static constexpr unsigned long variant{327};
12450 static constexpr bool concrete{true};
12451 using subclasses_t = mp::List<>;
12453};
12454template <> struct node_from_variant_t<327> { using type = SgChar32Val; };
12455
12456// Class: ChooseExpression
12457template <> struct describe_field_t<SgChooseExpression,SgExpression*,&SgChooseExpression::p_value> {
12458 using parent = SgChooseExpression;
12459 using field_type = SgExpression*;
12460 static constexpr size_t position{0};
12461 static constexpr char const * const name{"value"};
12462 static constexpr char const * const typestr{"SgExpression*"};
12463 static constexpr bool traverse{true};
12464 static constexpr auto mbr_ptr{&SgChooseExpression::p_value};
12465 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12466 using bind = Desc<SgChooseExpression, SgExpression* SgChooseExpression::*, &SgChooseExpression::p_value>;
12467};
12469 using node = SgChooseExpression;
12470 using base = SgExpression;
12471 static constexpr char const * const name{"ChooseExpression"};
12472 static constexpr unsigned long variant{328};
12473 static constexpr bool concrete{true};
12474 using subclasses_t = mp::List<>;
12476};
12477template <> struct node_from_variant_t<328> { using type = SgChooseExpression; };
12478
12479// Class: ClassDecl_attr
12481 using node = SgClassDecl_attr;
12482 using base = SgBitAttribute;
12483 static constexpr char const * const name{"ClassDecl_attr"};
12484 static constexpr unsigned long variant{329};
12485 static constexpr bool concrete{true};
12486 using subclasses_t = mp::List<>;
12487 using fields_t = mp::List<>;
12488};
12489template <> struct node_from_variant_t<329> { using type = SgClassDecl_attr; };
12490
12491// Class: ClassDeclaration
12493 using parent = SgClassDeclaration;
12494 using field_type = SgName;
12495 static constexpr size_t position{0};
12496 static constexpr char const * const name{"name"};
12497 static constexpr char const * const typestr{"SgName"};
12498 static constexpr bool traverse{false};
12499 static constexpr auto mbr_ptr{&SgClassDeclaration::p_name};
12500 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12501 using bind = Desc<SgClassDeclaration, SgName SgClassDeclaration::*, &SgClassDeclaration::p_name>;
12502};
12504 using parent = SgClassDeclaration;
12506 static constexpr size_t position{1};
12507 static constexpr char const * const name{"class_type"};
12508 static constexpr char const * const typestr{"SgClassDeclaration::class_types"};
12509 static constexpr bool traverse{false};
12510 static constexpr auto mbr_ptr{&SgClassDeclaration::p_class_type};
12511 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12512 using bind = Desc<SgClassDeclaration, SgClassDeclaration::class_types SgClassDeclaration::*, &SgClassDeclaration::p_class_type>;
12513};
12515 using parent = SgClassDeclaration;
12516 using field_type = SgClassType*;
12517 static constexpr size_t position{2};
12518 static constexpr char const * const name{"type"};
12519 static constexpr char const * const typestr{"SgClassType*"};
12520 static constexpr bool traverse{false};
12521 static constexpr auto mbr_ptr{&SgClassDeclaration::p_type};
12522 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12523 using bind = Desc<SgClassDeclaration, SgClassType* SgClassDeclaration::*, &SgClassDeclaration::p_type>;
12524};
12526 using parent = SgClassDeclaration;
12528 static constexpr size_t position{3};
12529 static constexpr char const * const name{"definition"};
12530 static constexpr char const * const typestr{"SgClassDefinition*"};
12531 static constexpr bool traverse{true};
12532 static constexpr auto mbr_ptr{&SgClassDeclaration::p_definition};
12533 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12534 using bind = Desc<SgClassDeclaration, SgClassDefinition* SgClassDeclaration::*, &SgClassDeclaration::p_definition>;
12535};
12536template <> struct describe_field_t<SgClassDeclaration,SgScopeStatement*,&SgClassDeclaration::p_scope> {
12537 using parent = SgClassDeclaration;
12539 static constexpr size_t position{4};
12540 static constexpr char const * const name{"scope"};
12541 static constexpr char const * const typestr{"SgScopeStatement*"};
12542 static constexpr bool traverse{false};
12543 static constexpr auto mbr_ptr{&SgClassDeclaration::p_scope};
12544 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12545 using bind = Desc<SgClassDeclaration, SgScopeStatement* SgClassDeclaration::*, &SgClassDeclaration::p_scope>;
12546};
12547template <> struct describe_field_t<SgClassDeclaration,SgDeclarationStatement::template_specialization_enum,&SgClassDeclaration::p_specialization> {
12548 using parent = SgClassDeclaration;
12550 static constexpr size_t position{5};
12551 static constexpr char const * const name{"specialization"};
12552 static constexpr char const * const typestr{"SgDeclarationStatement::template_specialization_enum"};
12553 static constexpr bool traverse{false};
12554 static constexpr auto mbr_ptr{&SgClassDeclaration::p_specialization};
12555 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12556 using bind = Desc<SgClassDeclaration, SgDeclarationStatement::template_specialization_enum SgClassDeclaration::*, &SgClassDeclaration::p_specialization>;
12557};
12559 using parent = SgClassDeclaration;
12560 using field_type = bool;
12561 static constexpr size_t position{6};
12562 static constexpr char const * const name{"from_template"};
12563 static constexpr char const * const typestr{"bool"};
12564 static constexpr bool traverse{false};
12565 static constexpr auto mbr_ptr{&SgClassDeclaration::p_from_template};
12566 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12567 using bind = Desc<SgClassDeclaration, bool SgClassDeclaration::*, &SgClassDeclaration::p_from_template>;
12568};
12569template <> struct describe_field_t<SgClassDeclaration,bool,&SgClassDeclaration::p_fixupScope> {
12570 using parent = SgClassDeclaration;
12571 using field_type = bool;
12572 static constexpr size_t position{7};
12573 static constexpr char const * const name{"fixupScope"};
12574 static constexpr char const * const typestr{"bool"};
12575 static constexpr bool traverse{false};
12576 static constexpr auto mbr_ptr{&SgClassDeclaration::p_fixupScope};
12577 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12578 using bind = Desc<SgClassDeclaration, bool SgClassDeclaration::*, &SgClassDeclaration::p_fixupScope>;
12579};
12580template <> struct describe_field_t<SgClassDeclaration,bool,&SgClassDeclaration::p_isUnNamed> {
12581 using parent = SgClassDeclaration;
12582 using field_type = bool;
12583 static constexpr size_t position{8};
12584 static constexpr char const * const name{"isUnNamed"};
12585 static constexpr char const * const typestr{"bool"};
12586 static constexpr bool traverse{false};
12587 static constexpr auto mbr_ptr{&SgClassDeclaration::p_isUnNamed};
12588 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12589 using bind = Desc<SgClassDeclaration, bool SgClassDeclaration::*, &SgClassDeclaration::p_isUnNamed>;
12590};
12591template <> struct describe_field_t<SgClassDeclaration,bool,&SgClassDeclaration::p_explicit_annotation_interface> {
12592 using parent = SgClassDeclaration;
12593 using field_type = bool;
12594 static constexpr size_t position{9};
12595 static constexpr char const * const name{"explicit_annotation_interface"};
12596 static constexpr char const * const typestr{"bool"};
12597 static constexpr bool traverse{false};
12598 static constexpr auto mbr_ptr{&SgClassDeclaration::p_explicit_annotation_interface};
12599 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12600 using bind = Desc<SgClassDeclaration, bool SgClassDeclaration::*, &SgClassDeclaration::p_explicit_annotation_interface>;
12601};
12602template <> struct describe_field_t<SgClassDeclaration,bool,&SgClassDeclaration::p_explicit_interface> {
12603 using parent = SgClassDeclaration;
12604 using field_type = bool;
12605 static constexpr size_t position{10};
12606 static constexpr char const * const name{"explicit_interface"};
12607 static constexpr char const * const typestr{"bool"};
12608 static constexpr bool traverse{false};
12609 static constexpr auto mbr_ptr{&SgClassDeclaration::p_explicit_interface};
12610 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12611 using bind = Desc<SgClassDeclaration, bool SgClassDeclaration::*, &SgClassDeclaration::p_explicit_interface>;
12612};
12613template <> struct describe_field_t<SgClassDeclaration,bool,&SgClassDeclaration::p_explicit_enum> {
12614 using parent = SgClassDeclaration;
12615 using field_type = bool;
12616 static constexpr size_t position{11};
12617 static constexpr char const * const name{"explicit_enum"};
12618 static constexpr char const * const typestr{"bool"};
12619 static constexpr bool traverse{false};
12620 static constexpr auto mbr_ptr{&SgClassDeclaration::p_explicit_enum};
12621 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12622 using bind = Desc<SgClassDeclaration, bool SgClassDeclaration::*, &SgClassDeclaration::p_explicit_enum>;
12623};
12624template <> struct describe_field_t<SgClassDeclaration,bool,&SgClassDeclaration::p_explicit_anonymous> {
12625 using parent = SgClassDeclaration;
12626 using field_type = bool;
12627 static constexpr size_t position{12};
12628 static constexpr char const * const name{"explicit_anonymous"};
12629 static constexpr char const * const typestr{"bool"};
12630 static constexpr bool traverse{false};
12631 static constexpr auto mbr_ptr{&SgClassDeclaration::p_explicit_anonymous};
12632 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12633 using bind = Desc<SgClassDeclaration, bool SgClassDeclaration::*, &SgClassDeclaration::p_explicit_anonymous>;
12634};
12635template <> struct describe_field_t<SgClassDeclaration,SgExprListExp*,&SgClassDeclaration::p_decoratorList> {
12636 using parent = SgClassDeclaration;
12637 using field_type = SgExprListExp*;
12638 static constexpr size_t position{13};
12639 static constexpr char const * const name{"decoratorList"};
12640 static constexpr char const * const typestr{"SgExprListExp*"};
12641 static constexpr bool traverse{true};
12642 static constexpr auto mbr_ptr{&SgClassDeclaration::p_decoratorList};
12643 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12644 using bind = Desc<SgClassDeclaration, SgExprListExp* SgClassDeclaration::*, &SgClassDeclaration::p_decoratorList>;
12645};
12646template <> struct describe_field_t<SgClassDeclaration,int,&SgClassDeclaration::p_name_qualification_length> {
12647 using parent = SgClassDeclaration;
12648 using field_type = int;
12649 static constexpr size_t position{14};
12650 static constexpr char const * const name{"name_qualification_length"};
12651 static constexpr char const * const typestr{"int"};
12652 static constexpr bool traverse{false};
12653 static constexpr auto mbr_ptr{&SgClassDeclaration::p_name_qualification_length};
12654 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12655 using bind = Desc<SgClassDeclaration, int SgClassDeclaration::*, &SgClassDeclaration::p_name_qualification_length>;
12656};
12657template <> struct describe_field_t<SgClassDeclaration,bool,&SgClassDeclaration::p_type_elaboration_required> {
12658 using parent = SgClassDeclaration;
12659 using field_type = bool;
12660 static constexpr size_t position{15};
12661 static constexpr char const * const name{"type_elaboration_required"};
12662 static constexpr char const * const typestr{"bool"};
12663 static constexpr bool traverse{false};
12664 static constexpr auto mbr_ptr{&SgClassDeclaration::p_type_elaboration_required};
12665 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12666 using bind = Desc<SgClassDeclaration, bool SgClassDeclaration::*, &SgClassDeclaration::p_type_elaboration_required>;
12667};
12668template <> struct describe_field_t<SgClassDeclaration,bool,&SgClassDeclaration::p_global_qualification_required> {
12669 using parent = SgClassDeclaration;
12670 using field_type = bool;
12671 static constexpr size_t position{16};
12672 static constexpr char const * const name{"global_qualification_required"};
12673 static constexpr char const * const typestr{"bool"};
12674 static constexpr bool traverse{false};
12675 static constexpr auto mbr_ptr{&SgClassDeclaration::p_global_qualification_required};
12676 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12677 using bind = Desc<SgClassDeclaration, bool SgClassDeclaration::*, &SgClassDeclaration::p_global_qualification_required>;
12678};
12679template <> struct describe_field_t<SgClassDeclaration,bool,&SgClassDeclaration::p_isAutonomousDeclaration> {
12680 using parent = SgClassDeclaration;
12681 using field_type = bool;
12682 static constexpr size_t position{17};
12683 static constexpr char const * const name{"isAutonomousDeclaration"};
12684 static constexpr char const * const typestr{"bool"};
12685 static constexpr bool traverse{false};
12686 static constexpr auto mbr_ptr{&SgClassDeclaration::p_isAutonomousDeclaration};
12687 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12688 using bind = Desc<SgClassDeclaration, bool SgClassDeclaration::*, &SgClassDeclaration::p_isAutonomousDeclaration>;
12689};
12690template <> struct describe_field_t<SgClassDeclaration,bool,&SgClassDeclaration::p_isRepresentingTemplateParameterInTemplateDeclaration> {
12691 using parent = SgClassDeclaration;
12692 using field_type = bool;
12693 static constexpr size_t position{18};
12694 static constexpr char const * const name{"isRepresentingTemplateParameterInTemplateDeclaration"};
12695 static constexpr char const * const typestr{"bool"};
12696 static constexpr bool traverse{false};
12697 static constexpr auto mbr_ptr{&SgClassDeclaration::p_isRepresentingTemplateParameterInTemplateDeclaration};
12698 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12699 using bind = Desc<SgClassDeclaration, bool SgClassDeclaration::*, &SgClassDeclaration::p_isRepresentingTemplateParameterInTemplateDeclaration>;
12700};
12701template <> struct describe_field_t<SgClassDeclaration,SgBaseClass*,&SgClassDeclaration::p_adaParentType> {
12702 using parent = SgClassDeclaration;
12703 using field_type = SgBaseClass*;
12704 static constexpr size_t position{19};
12705 static constexpr char const * const name{"adaParentType"};
12706 static constexpr char const * const typestr{"SgBaseClass*"};
12707 static constexpr bool traverse{false};
12708 static constexpr auto mbr_ptr{&SgClassDeclaration::p_adaParentType};
12709 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12710 using bind = Desc<SgClassDeclaration, SgBaseClass* SgClassDeclaration::*, &SgClassDeclaration::p_adaParentType>;
12711};
12713 using node = SgClassDeclaration;
12715 static constexpr char const * const name{"ClassDeclaration"};
12716 static constexpr unsigned long variant{330};
12717 static constexpr bool concrete{true};
12719 using fields_t = mp::List<describe_field_t<SgClassDeclaration,SgName,&SgClassDeclaration::p_name>, describe_field_t<SgClassDeclaration,SgClassDeclaration::class_types,&SgClassDeclaration::p_class_type>, describe_field_t<SgClassDeclaration,SgClassType*,&SgClassDeclaration::p_type>, describe_field_t<SgClassDeclaration,SgClassDefinition*,&SgClassDeclaration::p_definition>, describe_field_t<SgClassDeclaration,SgScopeStatement*,&SgClassDeclaration::p_scope>, describe_field_t<SgClassDeclaration,SgDeclarationStatement::template_specialization_enum,&SgClassDeclaration::p_specialization>, describe_field_t<SgClassDeclaration,bool,&SgClassDeclaration::p_from_template>, describe_field_t<SgClassDeclaration,bool,&SgClassDeclaration::p_fixupScope>, describe_field_t<SgClassDeclaration,bool,&SgClassDeclaration::p_isUnNamed>, describe_field_t<SgClassDeclaration,bool,&SgClassDeclaration::p_explicit_annotation_interface>, describe_field_t<SgClassDeclaration,bool,&SgClassDeclaration::p_explicit_interface>, describe_field_t<SgClassDeclaration,bool,&SgClassDeclaration::p_explicit_enum>, describe_field_t<SgClassDeclaration,bool,&SgClassDeclaration::p_explicit_anonymous>, describe_field_t<SgClassDeclaration,SgExprListExp*,&SgClassDeclaration::p_decoratorList>, describe_field_t<SgClassDeclaration,int,&SgClassDeclaration::p_name_qualification_length>, describe_field_t<SgClassDeclaration,bool,&SgClassDeclaration::p_type_elaboration_required>, describe_field_t<SgClassDeclaration,bool,&SgClassDeclaration::p_global_qualification_required>, describe_field_t<SgClassDeclaration,bool,&SgClassDeclaration::p_isAutonomousDeclaration>, describe_field_t<SgClassDeclaration,bool,&SgClassDeclaration::p_isRepresentingTemplateParameterInTemplateDeclaration>, describe_field_t<SgClassDeclaration,SgBaseClass*,&SgClassDeclaration::p_adaParentType>>;
12720};
12721template <> struct node_from_variant_t<330> { using type = SgClassDeclaration; };
12722
12723// Class: ClassDefinition
12724template <> struct describe_field_t<SgClassDefinition,SgDeclarationStatementPtrList,&SgClassDefinition::p_members> {
12725 using parent = SgClassDefinition;
12726 using field_type = SgDeclarationStatementPtrList;
12727 static constexpr size_t position{0};
12728 static constexpr char const * const name{"members"};
12729 static constexpr char const * const typestr{"SgDeclarationStatementPtrList"};
12730 static constexpr bool traverse{true};
12731 static constexpr auto mbr_ptr{&SgClassDefinition::p_members};
12732 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12733 using bind = Desc<SgClassDefinition, SgDeclarationStatementPtrList SgClassDefinition::*, &SgClassDefinition::p_members>;
12734};
12736 using parent = SgClassDefinition;
12737 using field_type = SgBaseClassPtrList;
12738 static constexpr size_t position{1};
12739 static constexpr char const * const name{"inheritances"};
12740 static constexpr char const * const typestr{"SgBaseClassPtrList"};
12741 static constexpr bool traverse{false};
12742 static constexpr auto mbr_ptr{&SgClassDefinition::p_inheritances};
12743 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12744 using bind = Desc<SgClassDefinition, SgBaseClassPtrList SgClassDefinition::*, &SgClassDefinition::p_inheritances>;
12745};
12746template <> struct describe_field_t<SgClassDefinition,unsigned int,&SgClassDefinition::p_packingAlignment> {
12747 using parent = SgClassDefinition;
12748 using field_type = unsigned int;
12749 static constexpr size_t position{2};
12750 static constexpr char const * const name{"packingAlignment"};
12751 static constexpr char const * const typestr{"unsigned int"};
12752 static constexpr bool traverse{false};
12753 static constexpr auto mbr_ptr{&SgClassDefinition::p_packingAlignment};
12754 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12755 using bind = Desc<SgClassDefinition, unsigned int SgClassDefinition::*, &SgClassDefinition::p_packingAlignment>;
12756};
12757template <> struct describe_field_t<SgClassDefinition,bool,&SgClassDefinition::p_isSequence> {
12758 using parent = SgClassDefinition;
12759 using field_type = bool;
12760 static constexpr size_t position{3};
12761 static constexpr char const * const name{"isSequence"};
12762 static constexpr char const * const typestr{"bool"};
12763 static constexpr bool traverse{false};
12764 static constexpr auto mbr_ptr{&SgClassDefinition::p_isSequence};
12765 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12766 using bind = Desc<SgClassDefinition, bool SgClassDefinition::*, &SgClassDefinition::p_isSequence>;
12767};
12768template <> struct describe_field_t<SgClassDefinition,bool,&SgClassDefinition::p_isPrivate> {
12769 using parent = SgClassDefinition;
12770 using field_type = bool;
12771 static constexpr size_t position{4};
12772 static constexpr char const * const name{"isPrivate"};
12773 static constexpr char const * const typestr{"bool"};
12774 static constexpr bool traverse{false};
12775 static constexpr auto mbr_ptr{&SgClassDefinition::p_isPrivate};
12776 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12777 using bind = Desc<SgClassDefinition, bool SgClassDefinition::*, &SgClassDefinition::p_isPrivate>;
12778};
12779template <> struct describe_field_t<SgClassDefinition,bool,&SgClassDefinition::p_isAbstract> {
12780 using parent = SgClassDefinition;
12781 using field_type = bool;
12782 static constexpr size_t position{5};
12783 static constexpr char const * const name{"isAbstract"};
12784 static constexpr char const * const typestr{"bool"};
12785 static constexpr bool traverse{false};
12786 static constexpr auto mbr_ptr{&SgClassDefinition::p_isAbstract};
12787 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12788 using bind = Desc<SgClassDefinition, bool SgClassDefinition::*, &SgClassDefinition::p_isAbstract>;
12789};
12799template <> struct node_from_variant_t<331> { using type = SgClassDefinition; };
12800
12801// Class: ClassNameRefExp
12803 using parent = SgClassNameRefExp;
12804 using field_type = SgClassSymbol*;
12805 static constexpr size_t position{0};
12806 static constexpr char const * const name{"symbol"};
12807 static constexpr char const * const typestr{"SgClassSymbol*"};
12808 static constexpr bool traverse{false};
12809 static constexpr auto mbr_ptr{&SgClassNameRefExp::p_symbol};
12810 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12811 using bind = Desc<SgClassNameRefExp, SgClassSymbol* SgClassNameRefExp::*, &SgClassNameRefExp::p_symbol>;
12812};
12814 using node = SgClassNameRefExp;
12815 using base = SgReferenceExp;
12816 static constexpr char const * const name{"ClassNameRefExp"};
12817 static constexpr unsigned long variant{332};
12818 static constexpr bool concrete{true};
12819 using subclasses_t = mp::List<>;
12821};
12822template <> struct node_from_variant_t<332> { using type = SgClassNameRefExp; };
12823
12824// Class: ClassSymbol
12825template <> struct describe_field_t<SgClassSymbol,SgClassDeclaration*,&SgClassSymbol::p_declaration> {
12826 using parent = SgClassSymbol;
12828 static constexpr size_t position{0};
12829 static constexpr char const * const name{"declaration"};
12830 static constexpr char const * const typestr{"SgClassDeclaration*"};
12831 static constexpr bool traverse{true};
12832 static constexpr auto mbr_ptr{&SgClassSymbol::p_declaration};
12833 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12834 using bind = Desc<SgClassSymbol, SgClassDeclaration* SgClassSymbol::*, &SgClassSymbol::p_declaration>;
12835};
12836template <> struct describe_node_t<SgClassSymbol> {
12837 using node = SgClassSymbol;
12838 using base = SgTypeSymbol;
12839 static constexpr char const * const name{"ClassSymbol"};
12840 static constexpr unsigned long variant{333};
12841 static constexpr bool concrete{true};
12844};
12845template <> struct node_from_variant_t<333> { using type = SgClassSymbol; };
12846
12847// Class: ClassType
12848template <> struct describe_field_t<SgClassType,bool,&SgClassType::p_packed> {
12849 using parent = SgClassType;
12850 using field_type = bool;
12851 static constexpr size_t position{0};
12852 static constexpr char const * const name{"packed"};
12853 static constexpr char const * const typestr{"bool"};
12854 static constexpr bool traverse{false};
12855 static constexpr auto mbr_ptr{&SgClassType::p_packed};
12856 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12857 using bind = Desc<SgClassType, bool SgClassType::*, &SgClassType::p_packed>;
12858};
12859template <> struct describe_node_t<SgClassType> {
12860 using node = SgClassType;
12861 using base = SgNamedType;
12862 static constexpr char const * const name{"ClassType"};
12863 static constexpr unsigned long variant{334};
12864 static constexpr bool concrete{true};
12867};
12868template <> struct node_from_variant_t<334> { using type = SgClassType; };
12869
12870// Class: ClinkageDeclarationStatement
12871template <> struct describe_field_t<SgClinkageDeclarationStatement,std::string,&SgClinkageDeclarationStatement::p_languageSpecifier> {
12873 using field_type = std::string;
12874 static constexpr size_t position{0};
12875 static constexpr char const * const name{"languageSpecifier"};
12876 static constexpr char const * const typestr{"std::string"};
12877 static constexpr bool traverse{false};
12878 static constexpr auto mbr_ptr{&SgClinkageDeclarationStatement::p_languageSpecifier};
12879 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12880 using bind = Desc<SgClinkageDeclarationStatement, std::string SgClinkageDeclarationStatement::*, &SgClinkageDeclarationStatement::p_languageSpecifier>;
12881};
12885 static constexpr char const * const name{"ClinkageDeclarationStatement"};
12886 static constexpr unsigned long variant{335};
12887 static constexpr bool concrete{false};
12890};
12891template <> struct node_from_variant_t<335> { using type = SgClinkageDeclarationStatement; };
12892
12893// Class: ClinkageEndStatement
12897 static constexpr char const * const name{"ClinkageEndStatement"};
12898 static constexpr unsigned long variant{336};
12899 static constexpr bool concrete{true};
12900 using subclasses_t = mp::List<>;
12901 using fields_t = mp::List<>;
12902};
12903template <> struct node_from_variant_t<336> { using type = SgClinkageEndStatement; };
12904
12905// Class: ClinkageStartStatement
12909 static constexpr char const * const name{"ClinkageStartStatement"};
12910 static constexpr unsigned long variant{337};
12911 static constexpr bool concrete{true};
12912 using subclasses_t = mp::List<>;
12913 using fields_t = mp::List<>;
12914};
12915template <> struct node_from_variant_t<337> { using type = SgClinkageStartStatement; };
12916
12917// Class: CloseStatement
12918template <> struct describe_field_t<SgCloseStatement,SgExpression*,&SgCloseStatement::p_status> {
12919 using parent = SgCloseStatement;
12920 using field_type = SgExpression*;
12921 static constexpr size_t position{0};
12922 static constexpr char const * const name{"status"};
12923 static constexpr char const * const typestr{"SgExpression*"};
12924 static constexpr bool traverse{true};
12925 static constexpr auto mbr_ptr{&SgCloseStatement::p_status};
12926 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12927 using bind = Desc<SgCloseStatement, SgExpression* SgCloseStatement::*, &SgCloseStatement::p_status>;
12928};
12930 using node = SgCloseStatement;
12931 using base = SgIOStatement;
12932 static constexpr char const * const name{"CloseStatement"};
12933 static constexpr unsigned long variant{338};
12934 static constexpr bool concrete{true};
12935 using subclasses_t = mp::List<>;
12937};
12938template <> struct node_from_variant_t<338> { using type = SgCloseStatement; };
12939
12940// Class: ColonShapeExp
12942 using node = SgColonShapeExp;
12943 using base = SgExpression;
12944 static constexpr char const * const name{"ColonShapeExp"};
12945 static constexpr unsigned long variant{339};
12946 static constexpr bool concrete{true};
12947 using subclasses_t = mp::List<>;
12948 using fields_t = mp::List<>;
12949};
12950template <> struct node_from_variant_t<339> { using type = SgColonShapeExp; };
12951
12952// Class: CommaOpExp
12953template <> struct describe_node_t<SgCommaOpExp> {
12954 using node = SgCommaOpExp;
12955 using base = SgBinaryOp;
12956 static constexpr char const * const name{"CommaOpExp"};
12957 static constexpr unsigned long variant{340};
12958 static constexpr bool concrete{true};
12959 using subclasses_t = mp::List<>;
12960 using fields_t = mp::List<>;
12961};
12962template <> struct node_from_variant_t<340> { using type = SgCommaOpExp; };
12963
12964// Class: CommonBlock
12965template <> struct describe_field_t<SgCommonBlock,SgCommonBlockObjectPtrList,&SgCommonBlock::p_block_list> {
12966 using parent = SgCommonBlock;
12967 using field_type = SgCommonBlockObjectPtrList;
12968 static constexpr size_t position{0};
12969 static constexpr char const * const name{"block_list"};
12970 static constexpr char const * const typestr{"SgCommonBlockObjectPtrList"};
12971 static constexpr bool traverse{true};
12972 static constexpr auto mbr_ptr{&SgCommonBlock::p_block_list};
12973 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12974 using bind = Desc<SgCommonBlock, SgCommonBlockObjectPtrList SgCommonBlock::*, &SgCommonBlock::p_block_list>;
12975};
12976template <> struct describe_node_t<SgCommonBlock> {
12977 using node = SgCommonBlock;
12979 static constexpr char const * const name{"CommonBlock"};
12980 static constexpr unsigned long variant{341};
12981 static constexpr bool concrete{true};
12982 using subclasses_t = mp::List<>;
12984};
12985template <> struct node_from_variant_t<341> { using type = SgCommonBlock; };
12986
12987// Class: CommonBlockObject
12988template <> struct describe_field_t<SgCommonBlockObject,std::string,&SgCommonBlockObject::p_block_name> {
12990 using field_type = std::string;
12991 static constexpr size_t position{0};
12992 static constexpr char const * const name{"block_name"};
12993 static constexpr char const * const typestr{"std::string"};
12994 static constexpr bool traverse{false};
12995 static constexpr auto mbr_ptr{&SgCommonBlockObject::p_block_name};
12996 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
12997 using bind = Desc<SgCommonBlockObject, std::string SgCommonBlockObject::*, &SgCommonBlockObject::p_block_name>;
12998};
12999template <> struct describe_field_t<SgCommonBlockObject,SgExprListExp*,&SgCommonBlockObject::p_variable_reference_list> {
13001 using field_type = SgExprListExp*;
13002 static constexpr size_t position{1};
13003 static constexpr char const * const name{"variable_reference_list"};
13004 static constexpr char const * const typestr{"SgExprListExp*"};
13005 static constexpr bool traverse{true};
13006 static constexpr auto mbr_ptr{&SgCommonBlockObject::p_variable_reference_list};
13007 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13008 using bind = Desc<SgCommonBlockObject, SgExprListExp* SgCommonBlockObject::*, &SgCommonBlockObject::p_variable_reference_list>;
13009};
13011 using node = SgCommonBlockObject;
13012 using base = SgLocatedNodeSupport;
13013 static constexpr char const * const name{"CommonBlockObject"};
13014 static constexpr unsigned long variant{342};
13015 static constexpr bool concrete{true};
13016 using subclasses_t = mp::List<>;
13018};
13019template <> struct node_from_variant_t<342> { using type = SgCommonBlockObject; };
13020
13021// Class: CommonSymbol
13022template <> struct describe_field_t<SgCommonSymbol,SgInitializedName*,&SgCommonSymbol::p_declaration> {
13023 using parent = SgCommonSymbol;
13025 static constexpr size_t position{0};
13026 static constexpr char const * const name{"declaration"};
13027 static constexpr char const * const typestr{"SgInitializedName*"};
13028 static constexpr bool traverse{false};
13029 static constexpr auto mbr_ptr{&SgCommonSymbol::p_declaration};
13030 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13031 using bind = Desc<SgCommonSymbol, SgInitializedName* SgCommonSymbol::*, &SgCommonSymbol::p_declaration>;
13032};
13033template <> struct describe_node_t<SgCommonSymbol> {
13034 using node = SgCommonSymbol;
13035 using base = SgSymbol;
13036 static constexpr char const * const name{"CommonSymbol"};
13037 static constexpr unsigned long variant{343};
13038 static constexpr bool concrete{true};
13039 using subclasses_t = mp::List<>;
13041};
13042template <> struct node_from_variant_t<343> { using type = SgCommonSymbol; };
13043
13044// Class: ComplexVal
13045template <> struct describe_field_t<SgComplexVal,SgValueExp*,&SgComplexVal::p_real_value> {
13046 using parent = SgComplexVal;
13047 using field_type = SgValueExp*;
13048 static constexpr size_t position{0};
13049 static constexpr char const * const name{"real_value"};
13050 static constexpr char const * const typestr{"SgValueExp*"};
13051 static constexpr bool traverse{true};
13052 static constexpr auto mbr_ptr{&SgComplexVal::p_real_value};
13053 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13054 using bind = Desc<SgComplexVal, SgValueExp* SgComplexVal::*, &SgComplexVal::p_real_value>;
13055};
13056template <> struct describe_field_t<SgComplexVal,SgValueExp*,&SgComplexVal::p_imaginary_value> {
13057 using parent = SgComplexVal;
13058 using field_type = SgValueExp*;
13059 static constexpr size_t position{1};
13060 static constexpr char const * const name{"imaginary_value"};
13061 static constexpr char const * const typestr{"SgValueExp*"};
13062 static constexpr bool traverse{true};
13063 static constexpr auto mbr_ptr{&SgComplexVal::p_imaginary_value};
13064 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13065 using bind = Desc<SgComplexVal, SgValueExp* SgComplexVal::*, &SgComplexVal::p_imaginary_value>;
13066};
13067template <> struct describe_field_t<SgComplexVal,SgType*,&SgComplexVal::p_precisionType> {
13068 using parent = SgComplexVal;
13069 using field_type = SgType*;
13070 static constexpr size_t position{2};
13071 static constexpr char const * const name{"precisionType"};
13072 static constexpr char const * const typestr{"SgType*"};
13073 static constexpr bool traverse{false};
13074 static constexpr auto mbr_ptr{&SgComplexVal::p_precisionType};
13075 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13076 using bind = Desc<SgComplexVal, SgType* SgComplexVal::*, &SgComplexVal::p_precisionType>;
13077};
13078template <> struct describe_field_t<SgComplexVal,std::string,&SgComplexVal::p_valueString> {
13079 using parent = SgComplexVal;
13080 using field_type = std::string;
13081 static constexpr size_t position{3};
13082 static constexpr char const * const name{"valueString"};
13083 static constexpr char const * const typestr{"std::string"};
13084 static constexpr bool traverse{false};
13085 static constexpr auto mbr_ptr{&SgComplexVal::p_valueString};
13086 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13087 using bind = Desc<SgComplexVal, std::string SgComplexVal::*, &SgComplexVal::p_valueString>;
13088};
13089template <> struct describe_node_t<SgComplexVal> {
13090 using node = SgComplexVal;
13091 using base = SgValueExp;
13092 static constexpr char const * const name{"ComplexVal"};
13093 static constexpr unsigned long variant{344};
13094 static constexpr bool concrete{true};
13095 using subclasses_t = mp::List<>;
13097};
13098template <> struct node_from_variant_t<344> { using type = SgComplexVal; };
13099
13100// Class: Comprehension
13101template <> struct describe_field_t<SgComprehension,SgExpression*,&SgComprehension::p_target> {
13102 using parent = SgComprehension;
13103 using field_type = SgExpression*;
13104 static constexpr size_t position{0};
13105 static constexpr char const * const name{"target"};
13106 static constexpr char const * const typestr{"SgExpression*"};
13107 static constexpr bool traverse{true};
13108 static constexpr auto mbr_ptr{&SgComprehension::p_target};
13109 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13110 using bind = Desc<SgComprehension, SgExpression* SgComprehension::*, &SgComprehension::p_target>;
13111};
13112template <> struct describe_field_t<SgComprehension,SgExpression*,&SgComprehension::p_iter> {
13113 using parent = SgComprehension;
13114 using field_type = SgExpression*;
13115 static constexpr size_t position{1};
13116 static constexpr char const * const name{"iter"};
13117 static constexpr char const * const typestr{"SgExpression*"};
13118 static constexpr bool traverse{true};
13119 static constexpr auto mbr_ptr{&SgComprehension::p_iter};
13120 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13121 using bind = Desc<SgComprehension, SgExpression* SgComprehension::*, &SgComprehension::p_iter>;
13122};
13123template <> struct describe_field_t<SgComprehension,SgExprListExp*,&SgComprehension::p_filters> {
13124 using parent = SgComprehension;
13125 using field_type = SgExprListExp*;
13126 static constexpr size_t position{2};
13127 static constexpr char const * const name{"filters"};
13128 static constexpr char const * const typestr{"SgExprListExp*"};
13129 static constexpr bool traverse{true};
13130 static constexpr auto mbr_ptr{&SgComprehension::p_filters};
13131 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13132 using bind = Desc<SgComprehension, SgExprListExp* SgComprehension::*, &SgComprehension::p_filters>;
13133};
13135 using node = SgComprehension;
13136 using base = SgExpression;
13137 static constexpr char const * const name{"Comprehension"};
13138 static constexpr unsigned long variant{345};
13139 static constexpr bool concrete{true};
13140 using subclasses_t = mp::List<>;
13142};
13143template <> struct node_from_variant_t<345> { using type = SgComprehension; };
13144
13145// Class: CompoundAssignOp
13147 using node = SgCompoundAssignOp;
13148 using base = SgBinaryOp;
13149 static constexpr char const * const name{"CompoundAssignOp"};
13150 static constexpr unsigned long variant{347};
13151 static constexpr bool concrete{false};
13153 using fields_t = mp::List<>;
13154};
13155template <> struct node_from_variant_t<347> { using type = SgCompoundAssignOp; };
13156
13157// Class: CompoundInitializer
13158template <> struct describe_field_t<SgCompoundInitializer,SgExprListExp*,&SgCompoundInitializer::p_initializers> {
13160 using field_type = SgExprListExp*;
13161 static constexpr size_t position{0};
13162 static constexpr char const * const name{"initializers"};
13163 static constexpr char const * const typestr{"SgExprListExp*"};
13164 static constexpr bool traverse{true};
13165 static constexpr auto mbr_ptr{&SgCompoundInitializer::p_initializers};
13166 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13167 using bind = Desc<SgCompoundInitializer, SgExprListExp* SgCompoundInitializer::*, &SgCompoundInitializer::p_initializers>;
13168};
13169template <> struct describe_field_t<SgCompoundInitializer,SgType*,&SgCompoundInitializer::p_expression_type> {
13171 using field_type = SgType*;
13172 static constexpr size_t position{1};
13173 static constexpr char const * const name{"expression_type"};
13174 static constexpr char const * const typestr{"SgType*"};
13175 static constexpr bool traverse{false};
13176 static constexpr auto mbr_ptr{&SgCompoundInitializer::p_expression_type};
13177 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13178 using bind = Desc<SgCompoundInitializer, SgType* SgCompoundInitializer::*, &SgCompoundInitializer::p_expression_type>;
13179};
13182 using base = SgInitializer;
13183 static constexpr char const * const name{"CompoundInitializer"};
13184 static constexpr unsigned long variant{348};
13185 static constexpr bool concrete{true};
13186 using subclasses_t = mp::List<>;
13188};
13189template <> struct node_from_variant_t<348> { using type = SgCompoundInitializer; };
13190
13191// Class: CompoundLiteralExp
13192template <> struct describe_field_t<SgCompoundLiteralExp,SgVariableSymbol*,&SgCompoundLiteralExp::p_symbol> {
13195 static constexpr size_t position{0};
13196 static constexpr char const * const name{"symbol"};
13197 static constexpr char const * const typestr{"SgVariableSymbol*"};
13198 static constexpr bool traverse{false};
13199 static constexpr auto mbr_ptr{&SgCompoundLiteralExp::p_symbol};
13200 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13201 using bind = Desc<SgCompoundLiteralExp, SgVariableSymbol* SgCompoundLiteralExp::*, &SgCompoundLiteralExp::p_symbol>;
13202};
13204 using node = SgCompoundLiteralExp;
13205 using base = SgExpression;
13206 static constexpr char const * const name{"CompoundLiteralExp"};
13207 static constexpr unsigned long variant{349};
13208 static constexpr bool concrete{true};
13209 using subclasses_t = mp::List<>;
13211};
13212template <> struct node_from_variant_t<349> { using type = SgCompoundLiteralExp; };
13213
13214// Class: ComputedGotoStatement
13215template <> struct describe_field_t<SgComputedGotoStatement,SgExprListExp*,&SgComputedGotoStatement::p_labelList> {
13217 using field_type = SgExprListExp*;
13218 static constexpr size_t position{0};
13219 static constexpr char const * const name{"labelList"};
13220 static constexpr char const * const typestr{"SgExprListExp*"};
13221 static constexpr bool traverse{true};
13222 static constexpr auto mbr_ptr{&SgComputedGotoStatement::p_labelList};
13223 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13224 using bind = Desc<SgComputedGotoStatement, SgExprListExp* SgComputedGotoStatement::*, &SgComputedGotoStatement::p_labelList>;
13225};
13226template <> struct describe_field_t<SgComputedGotoStatement,SgExpression*,&SgComputedGotoStatement::p_label_index> {
13228 using field_type = SgExpression*;
13229 static constexpr size_t position{1};
13230 static constexpr char const * const name{"label_index"};
13231 static constexpr char const * const typestr{"SgExpression*"};
13232 static constexpr bool traverse{true};
13233 static constexpr auto mbr_ptr{&SgComputedGotoStatement::p_label_index};
13234 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13235 using bind = Desc<SgComputedGotoStatement, SgExpression* SgComputedGotoStatement::*, &SgComputedGotoStatement::p_label_index>;
13236};
13239 using base = SgStatement;
13240 static constexpr char const * const name{"ComputedGotoStatement"};
13241 static constexpr unsigned long variant{350};
13242 static constexpr bool concrete{true};
13243 using subclasses_t = mp::List<>;
13245};
13246template <> struct node_from_variant_t<350> { using type = SgComputedGotoStatement; };
13247
13248// Class: ConcatenationOp
13250 using node = SgConcatenationOp;
13251 using base = SgBinaryOp;
13252 static constexpr char const * const name{"ConcatenationOp"};
13253 static constexpr unsigned long variant{351};
13254 static constexpr bool concrete{true};
13255 using subclasses_t = mp::List<>;
13256 using fields_t = mp::List<>;
13257};
13258template <> struct node_from_variant_t<351> { using type = SgConcatenationOp; };
13259
13260// Class: ConditionalExp
13262 using parent = SgConditionalExp;
13263 using field_type = SgExpression*;
13264 static constexpr size_t position{0};
13265 static constexpr char const * const name{"conditional_exp"};
13266 static constexpr char const * const typestr{"SgExpression*"};
13267 static constexpr bool traverse{true};
13268 static constexpr auto mbr_ptr{&SgConditionalExp::p_conditional_exp};
13269 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13270 using bind = Desc<SgConditionalExp, SgExpression* SgConditionalExp::*, &SgConditionalExp::p_conditional_exp>;
13271};
13273 using parent = SgConditionalExp;
13274 using field_type = SgExpression*;
13275 static constexpr size_t position{1};
13276 static constexpr char const * const name{"true_exp"};
13277 static constexpr char const * const typestr{"SgExpression*"};
13278 static constexpr bool traverse{true};
13279 static constexpr auto mbr_ptr{&SgConditionalExp::p_true_exp};
13280 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13281 using bind = Desc<SgConditionalExp, SgExpression* SgConditionalExp::*, &SgConditionalExp::p_true_exp>;
13282};
13284 using parent = SgConditionalExp;
13285 using field_type = SgExpression*;
13286 static constexpr size_t position{2};
13287 static constexpr char const * const name{"false_exp"};
13288 static constexpr char const * const typestr{"SgExpression*"};
13289 static constexpr bool traverse{true};
13290 static constexpr auto mbr_ptr{&SgConditionalExp::p_false_exp};
13291 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13292 using bind = Desc<SgConditionalExp, SgExpression* SgConditionalExp::*, &SgConditionalExp::p_false_exp>;
13293};
13295 using parent = SgConditionalExp;
13296 using field_type = SgType*;
13297 static constexpr size_t position{3};
13298 static constexpr char const * const name{"expression_type"};
13299 static constexpr char const * const typestr{"SgType*"};
13300 static constexpr bool traverse{false};
13301 static constexpr auto mbr_ptr{&SgConditionalExp::p_expression_type};
13302 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13303 using bind = Desc<SgConditionalExp, SgType* SgConditionalExp::*, &SgConditionalExp::p_expression_type>;
13304};
13314template <> struct node_from_variant_t<352> { using type = SgConditionalExp; };
13315
13316// Class: ConjugateOp
13317template <> struct describe_node_t<SgConjugateOp> {
13318 using node = SgConjugateOp;
13319 using base = SgUnaryOp;
13320 static constexpr char const * const name{"ConjugateOp"};
13321 static constexpr unsigned long variant{353};
13322 static constexpr bool concrete{true};
13323 using subclasses_t = mp::List<>;
13324 using fields_t = mp::List<>;
13325};
13326template <> struct node_from_variant_t<353> { using type = SgConjugateOp; };
13327
13328// Class: ConstVolatileModifier
13329template <> struct describe_field_t<SgConstVolatileModifier,SgConstVolatileModifier::cv_modifier_enum,&SgConstVolatileModifier::p_modifier> {
13332 static constexpr size_t position{0};
13333 static constexpr char const * const name{"modifier"};
13334 static constexpr char const * const typestr{"SgConstVolatileModifier::cv_modifier_enum"};
13335 static constexpr bool traverse{false};
13336 static constexpr auto mbr_ptr{&SgConstVolatileModifier::p_modifier};
13337 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13338 using bind = Desc<SgConstVolatileModifier, SgConstVolatileModifier::cv_modifier_enum SgConstVolatileModifier::*, &SgConstVolatileModifier::p_modifier>;
13339};
13342 using base = SgModifier;
13343 static constexpr char const * const name{"ConstVolatileModifier"};
13344 static constexpr unsigned long variant{354};
13345 static constexpr bool concrete{true};
13346 using subclasses_t = mp::List<>;
13348};
13349template <> struct node_from_variant_t<354> { using type = SgConstVolatileModifier; };
13350
13351// Class: ConstructorInitializer
13355 static constexpr size_t position{0};
13356 static constexpr char const * const name{"declaration"};
13357 static constexpr char const * const typestr{"SgMemberFunctionDeclaration*"};
13358 static constexpr bool traverse{false};
13359 static constexpr auto mbr_ptr{&SgConstructorInitializer::p_declaration};
13360 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13361 using bind = Desc<SgConstructorInitializer, SgMemberFunctionDeclaration* SgConstructorInitializer::*, &SgConstructorInitializer::p_declaration>;
13362};
13365 using field_type = SgExprListExp*;
13366 static constexpr size_t position{1};
13367 static constexpr char const * const name{"args"};
13368 static constexpr char const * const typestr{"SgExprListExp*"};
13369 static constexpr bool traverse{true};
13370 static constexpr auto mbr_ptr{&SgConstructorInitializer::p_args};
13371 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13372 using bind = Desc<SgConstructorInitializer, SgExprListExp* SgConstructorInitializer::*, &SgConstructorInitializer::p_args>;
13373};
13376 using field_type = SgType*;
13377 static constexpr size_t position{2};
13378 static constexpr char const * const name{"expression_type"};
13379 static constexpr char const * const typestr{"SgType*"};
13380 static constexpr bool traverse{false};
13381 static constexpr auto mbr_ptr{&SgConstructorInitializer::p_expression_type};
13382 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13383 using bind = Desc<SgConstructorInitializer, SgType* SgConstructorInitializer::*, &SgConstructorInitializer::p_expression_type>;
13384};
13387 using field_type = bool;
13388 static constexpr size_t position{3};
13389 static constexpr char const * const name{"need_name"};
13390 static constexpr char const * const typestr{"bool"};
13391 static constexpr bool traverse{false};
13392 static constexpr auto mbr_ptr{&SgConstructorInitializer::p_need_name};
13393 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13394 using bind = Desc<SgConstructorInitializer, bool SgConstructorInitializer::*, &SgConstructorInitializer::p_need_name>;
13395};
13398 using field_type = bool;
13399 static constexpr size_t position{4};
13400 static constexpr char const * const name{"need_qualifier"};
13401 static constexpr char const * const typestr{"bool"};
13402 static constexpr bool traverse{false};
13403 static constexpr auto mbr_ptr{&SgConstructorInitializer::p_need_qualifier};
13404 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13405 using bind = Desc<SgConstructorInitializer, bool SgConstructorInitializer::*, &SgConstructorInitializer::p_need_qualifier>;
13406};
13409 using field_type = bool;
13410 static constexpr size_t position{5};
13411 static constexpr char const * const name{"need_parenthesis_after_name"};
13412 static constexpr char const * const typestr{"bool"};
13413 static constexpr bool traverse{false};
13414 static constexpr auto mbr_ptr{&SgConstructorInitializer::p_need_parenthesis_after_name};
13415 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13416 using bind = Desc<SgConstructorInitializer, bool SgConstructorInitializer::*, &SgConstructorInitializer::p_need_parenthesis_after_name>;
13417};
13420 using field_type = bool;
13421 static constexpr size_t position{6};
13422 static constexpr char const * const name{"associated_class_unknown"};
13423 static constexpr char const * const typestr{"bool"};
13424 static constexpr bool traverse{false};
13425 static constexpr auto mbr_ptr{&SgConstructorInitializer::p_associated_class_unknown};
13426 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13427 using bind = Desc<SgConstructorInitializer, bool SgConstructorInitializer::*, &SgConstructorInitializer::p_associated_class_unknown>;
13428};
13429template <> struct describe_field_t<SgConstructorInitializer,int,&SgConstructorInitializer::p_name_qualification_length> {
13431 using field_type = int;
13432 static constexpr size_t position{7};
13433 static constexpr char const * const name{"name_qualification_length"};
13434 static constexpr char const * const typestr{"int"};
13435 static constexpr bool traverse{false};
13436 static constexpr auto mbr_ptr{&SgConstructorInitializer::p_name_qualification_length};
13437 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13438 using bind = Desc<SgConstructorInitializer, int SgConstructorInitializer::*, &SgConstructorInitializer::p_name_qualification_length>;
13439};
13440template <> struct describe_field_t<SgConstructorInitializer,bool,&SgConstructorInitializer::p_type_elaboration_required> {
13442 using field_type = bool;
13443 static constexpr size_t position{8};
13444 static constexpr char const * const name{"type_elaboration_required"};
13445 static constexpr char const * const typestr{"bool"};
13446 static constexpr bool traverse{false};
13447 static constexpr auto mbr_ptr{&SgConstructorInitializer::p_type_elaboration_required};
13448 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13449 using bind = Desc<SgConstructorInitializer, bool SgConstructorInitializer::*, &SgConstructorInitializer::p_type_elaboration_required>;
13450};
13451template <> struct describe_field_t<SgConstructorInitializer,bool,&SgConstructorInitializer::p_global_qualification_required> {
13453 using field_type = bool;
13454 static constexpr size_t position{9};
13455 static constexpr char const * const name{"global_qualification_required"};
13456 static constexpr char const * const typestr{"bool"};
13457 static constexpr bool traverse{false};
13458 static constexpr auto mbr_ptr{&SgConstructorInitializer::p_global_qualification_required};
13459 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13460 using bind = Desc<SgConstructorInitializer, bool SgConstructorInitializer::*, &SgConstructorInitializer::p_global_qualification_required>;
13461};
13462template <> struct describe_field_t<SgConstructorInitializer,bool,&SgConstructorInitializer::p_is_used_in_conditional> {
13464 using field_type = bool;
13465 static constexpr size_t position{10};
13466 static constexpr char const * const name{"is_used_in_conditional"};
13467 static constexpr char const * const typestr{"bool"};
13468 static constexpr bool traverse{false};
13469 static constexpr auto mbr_ptr{&SgConstructorInitializer::p_is_used_in_conditional};
13470 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13471 using bind = Desc<SgConstructorInitializer, bool SgConstructorInitializer::*, &SgConstructorInitializer::p_is_used_in_conditional>;
13472};
13475 using base = SgInitializer;
13476 static constexpr char const * const name{"ConstructorInitializer"};
13477 static constexpr unsigned long variant{355};
13478 static constexpr bool concrete{true};
13479 using subclasses_t = mp::List<>;
13481};
13482template <> struct node_from_variant_t<355> { using type = SgConstructorInitializer; };
13483
13484// Class: ContainsStatement
13486 using node = SgContainsStatement;
13488 static constexpr char const * const name{"ContainsStatement"};
13489 static constexpr unsigned long variant{356};
13490 static constexpr bool concrete{true};
13491 using subclasses_t = mp::List<>;
13492 using fields_t = mp::List<>;
13493};
13494template <> struct node_from_variant_t<356> { using type = SgContainsStatement; };
13495
13496// Class: ContinueStmt
13497template <> struct describe_field_t<SgContinueStmt,std::string,&SgContinueStmt::p_do_string_label> {
13498 using parent = SgContinueStmt;
13499 using field_type = std::string;
13500 static constexpr size_t position{0};
13501 static constexpr char const * const name{"do_string_label"};
13502 static constexpr char const * const typestr{"std::string"};
13503 static constexpr bool traverse{false};
13504 static constexpr auto mbr_ptr{&SgContinueStmt::p_do_string_label};
13505 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13506 using bind = Desc<SgContinueStmt, std::string SgContinueStmt::*, &SgContinueStmt::p_do_string_label>;
13507};
13508template <> struct describe_node_t<SgContinueStmt> {
13509 using node = SgContinueStmt;
13510 using base = SgStatement;
13511 static constexpr char const * const name{"ContinueStmt"};
13512 static constexpr unsigned long variant{357};
13513 static constexpr bool concrete{true};
13514 using subclasses_t = mp::List<>;
13516};
13517template <> struct node_from_variant_t<357> { using type = SgContinueStmt; };
13518
13519// Class: CtorInitializerList
13520template <> struct describe_field_t<SgCtorInitializerList,SgInitializedNamePtrList,&SgCtorInitializerList::p_ctors> {
13522 using field_type = SgInitializedNamePtrList;
13523 static constexpr size_t position{0};
13524 static constexpr char const * const name{"ctors"};
13525 static constexpr char const * const typestr{"SgInitializedNamePtrList"};
13526 static constexpr bool traverse{true};
13527 static constexpr auto mbr_ptr{&SgCtorInitializerList::p_ctors};
13528 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13529 using bind = Desc<SgCtorInitializerList, SgInitializedNamePtrList SgCtorInitializerList::*, &SgCtorInitializerList::p_ctors>;
13530};
13534 static constexpr char const * const name{"CtorInitializerList"};
13535 static constexpr unsigned long variant{358};
13536 static constexpr bool concrete{true};
13537 using subclasses_t = mp::List<>;
13539};
13540template <> struct node_from_variant_t<358> { using type = SgCtorInitializerList; };
13541
13542// Class: DataStatementGroup
13543template <> struct describe_field_t<SgDataStatementGroup,SgDataStatementObjectPtrList,&SgDataStatementGroup::p_object_list> {
13545 using field_type = SgDataStatementObjectPtrList;
13546 static constexpr size_t position{0};
13547 static constexpr char const * const name{"object_list"};
13548 static constexpr char const * const typestr{"SgDataStatementObjectPtrList"};
13549 static constexpr bool traverse{false};
13550 static constexpr auto mbr_ptr{&SgDataStatementGroup::p_object_list};
13551 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13552 using bind = Desc<SgDataStatementGroup, SgDataStatementObjectPtrList SgDataStatementGroup::*, &SgDataStatementGroup::p_object_list>;
13553};
13554template <> struct describe_field_t<SgDataStatementGroup,SgDataStatementValuePtrList,&SgDataStatementGroup::p_value_list> {
13556 using field_type = SgDataStatementValuePtrList;
13557 static constexpr size_t position{1};
13558 static constexpr char const * const name{"value_list"};
13559 static constexpr char const * const typestr{"SgDataStatementValuePtrList"};
13560 static constexpr bool traverse{false};
13561 static constexpr auto mbr_ptr{&SgDataStatementGroup::p_value_list};
13562 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13563 using bind = Desc<SgDataStatementGroup, SgDataStatementValuePtrList SgDataStatementGroup::*, &SgDataStatementGroup::p_value_list>;
13564};
13566 using node = SgDataStatementGroup;
13567 using base = SgSupport;
13568 static constexpr char const * const name{"DataStatementGroup"};
13569 static constexpr unsigned long variant{359};
13570 static constexpr bool concrete{true};
13571 using subclasses_t = mp::List<>;
13573};
13574template <> struct node_from_variant_t<359> { using type = SgDataStatementGroup; };
13575
13576// Class: DataStatementObject
13577template <> struct describe_field_t<SgDataStatementObject,SgExprListExp*,&SgDataStatementObject::p_variableReference_list> {
13579 using field_type = SgExprListExp*;
13580 static constexpr size_t position{0};
13581 static constexpr char const * const name{"variableReference_list"};
13582 static constexpr char const * const typestr{"SgExprListExp*"};
13583 static constexpr bool traverse{false};
13584 static constexpr auto mbr_ptr{&SgDataStatementObject::p_variableReference_list};
13585 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13586 using bind = Desc<SgDataStatementObject, SgExprListExp* SgDataStatementObject::*, &SgDataStatementObject::p_variableReference_list>;
13587};
13590 using base = SgSupport;
13591 static constexpr char const * const name{"DataStatementObject"};
13592 static constexpr unsigned long variant{360};
13593 static constexpr bool concrete{true};
13594 using subclasses_t = mp::List<>;
13596};
13597template <> struct node_from_variant_t<360> { using type = SgDataStatementObject; };
13598
13599// Class: DataStatementValue
13600template <> struct describe_field_t<SgDataStatementValue,SgDataStatementValue::data_statement_value_enum,&SgDataStatementValue::p_data_initialization_format> {
13603 static constexpr size_t position{0};
13604 static constexpr char const * const name{"data_initialization_format"};
13605 static constexpr char const * const typestr{"SgDataStatementValue::data_statement_value_enum"};
13606 static constexpr bool traverse{false};
13607 static constexpr auto mbr_ptr{&SgDataStatementValue::p_data_initialization_format};
13608 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13609 using bind = Desc<SgDataStatementValue, SgDataStatementValue::data_statement_value_enum SgDataStatementValue::*, &SgDataStatementValue::p_data_initialization_format>;
13610};
13611template <> struct describe_field_t<SgDataStatementValue,SgExprListExp*,&SgDataStatementValue::p_initializer_list> {
13613 using field_type = SgExprListExp*;
13614 static constexpr size_t position{1};
13615 static constexpr char const * const name{"initializer_list"};
13616 static constexpr char const * const typestr{"SgExprListExp*"};
13617 static constexpr bool traverse{false};
13618 static constexpr auto mbr_ptr{&SgDataStatementValue::p_initializer_list};
13619 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13620 using bind = Desc<SgDataStatementValue, SgExprListExp* SgDataStatementValue::*, &SgDataStatementValue::p_initializer_list>;
13621};
13622template <> struct describe_field_t<SgDataStatementValue,SgExpression*,&SgDataStatementValue::p_repeat_expression> {
13624 using field_type = SgExpression*;
13625 static constexpr size_t position{2};
13626 static constexpr char const * const name{"repeat_expression"};
13627 static constexpr char const * const typestr{"SgExpression*"};
13628 static constexpr bool traverse{false};
13629 static constexpr auto mbr_ptr{&SgDataStatementValue::p_repeat_expression};
13630 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13631 using bind = Desc<SgDataStatementValue, SgExpression* SgDataStatementValue::*, &SgDataStatementValue::p_repeat_expression>;
13632};
13633template <> struct describe_field_t<SgDataStatementValue,SgExpression*,&SgDataStatementValue::p_constant_expression> {
13635 using field_type = SgExpression*;
13636 static constexpr size_t position{3};
13637 static constexpr char const * const name{"constant_expression"};
13638 static constexpr char const * const typestr{"SgExpression*"};
13639 static constexpr bool traverse{false};
13640 static constexpr auto mbr_ptr{&SgDataStatementValue::p_constant_expression};
13641 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13642 using bind = Desc<SgDataStatementValue, SgExpression* SgDataStatementValue::*, &SgDataStatementValue::p_constant_expression>;
13643};
13653template <> struct node_from_variant_t<361> { using type = SgDataStatementValue; };
13654
13655// Class: DeadIfDirectiveStatement
13659 static constexpr char const * const name{"DeadIfDirectiveStatement"};
13660 static constexpr unsigned long variant{362};
13661 static constexpr bool concrete{true};
13662 using subclasses_t = mp::List<>;
13663 using fields_t = mp::List<>;
13664};
13665template <> struct node_from_variant_t<362> { using type = SgDeadIfDirectiveStatement; };
13666
13667// Class: DeallocateStatement
13668template <> struct describe_field_t<SgDeallocateStatement,SgExprListExp*,&SgDeallocateStatement::p_expr_list> {
13670 using field_type = SgExprListExp*;
13671 static constexpr size_t position{0};
13672 static constexpr char const * const name{"expr_list"};
13673 static constexpr char const * const typestr{"SgExprListExp*"};
13674 static constexpr bool traverse{true};
13675 static constexpr auto mbr_ptr{&SgDeallocateStatement::p_expr_list};
13676 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13677 using bind = Desc<SgDeallocateStatement, SgExprListExp* SgDeallocateStatement::*, &SgDeallocateStatement::p_expr_list>;
13678};
13679template <> struct describe_field_t<SgDeallocateStatement,SgExpression*,&SgDeallocateStatement::p_stat_expression> {
13681 using field_type = SgExpression*;
13682 static constexpr size_t position{1};
13683 static constexpr char const * const name{"stat_expression"};
13684 static constexpr char const * const typestr{"SgExpression*"};
13685 static constexpr bool traverse{true};
13686 static constexpr auto mbr_ptr{&SgDeallocateStatement::p_stat_expression};
13687 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13688 using bind = Desc<SgDeallocateStatement, SgExpression* SgDeallocateStatement::*, &SgDeallocateStatement::p_stat_expression>;
13689};
13690template <> struct describe_field_t<SgDeallocateStatement,SgExpression*,&SgDeallocateStatement::p_errmsg_expression> {
13692 using field_type = SgExpression*;
13693 static constexpr size_t position{2};
13694 static constexpr char const * const name{"errmsg_expression"};
13695 static constexpr char const * const typestr{"SgExpression*"};
13696 static constexpr bool traverse{true};
13697 static constexpr auto mbr_ptr{&SgDeallocateStatement::p_errmsg_expression};
13698 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13699 using bind = Desc<SgDeallocateStatement, SgExpression* SgDeallocateStatement::*, &SgDeallocateStatement::p_errmsg_expression>;
13700};
13703 using base = SgStatement;
13704 static constexpr char const * const name{"DeallocateStatement"};
13705 static constexpr unsigned long variant{363};
13706 static constexpr bool concrete{true};
13707 using subclasses_t = mp::List<>;
13709};
13710template <> struct node_from_variant_t<363> { using type = SgDeallocateStatement; };
13711
13712// Class: DeclarationModifier
13715 using field_type = SgBitVector;
13716 static constexpr size_t position{0};
13717 static constexpr char const * const name{"modifierVector"};
13718 static constexpr char const * const typestr{"SgBitVector"};
13719 static constexpr bool traverse{false};
13720 static constexpr auto mbr_ptr{&SgDeclarationModifier::p_modifierVector};
13721 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13722 using bind = Desc<SgDeclarationModifier, SgBitVector SgDeclarationModifier::*, &SgDeclarationModifier::p_modifierVector>;
13723};
13726 using field_type = SgTypeModifier;
13727 static constexpr size_t position{1};
13728 static constexpr char const * const name{"typeModifier"};
13729 static constexpr char const * const typestr{"SgTypeModifier"};
13730 static constexpr bool traverse{false};
13731 static constexpr auto mbr_ptr{&SgDeclarationModifier::p_typeModifier};
13732 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13733 using bind = Desc<SgDeclarationModifier, SgTypeModifier SgDeclarationModifier::*, &SgDeclarationModifier::p_typeModifier>;
13734};
13738 static constexpr size_t position{2};
13739 static constexpr char const * const name{"accessModifier"};
13740 static constexpr char const * const typestr{"SgAccessModifier"};
13741 static constexpr bool traverse{false};
13742 static constexpr auto mbr_ptr{&SgDeclarationModifier::p_accessModifier};
13743 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13744 using bind = Desc<SgDeclarationModifier, SgAccessModifier SgDeclarationModifier::*, &SgDeclarationModifier::p_accessModifier>;
13745};
13749 static constexpr size_t position{3};
13750 static constexpr char const * const name{"storageModifier"};
13751 static constexpr char const * const typestr{"SgStorageModifier"};
13752 static constexpr bool traverse{false};
13753 static constexpr auto mbr_ptr{&SgDeclarationModifier::p_storageModifier};
13754 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13755 using bind = Desc<SgDeclarationModifier, SgStorageModifier SgDeclarationModifier::*, &SgDeclarationModifier::p_storageModifier>;
13756};
13757template <> struct describe_field_t<SgDeclarationModifier,std::string,&SgDeclarationModifier::p_gnu_attribute_section_name> {
13759 using field_type = std::string;
13760 static constexpr size_t position{4};
13761 static constexpr char const * const name{"gnu_attribute_section_name"};
13762 static constexpr char const * const typestr{"std::string"};
13763 static constexpr bool traverse{false};
13764 static constexpr auto mbr_ptr{&SgDeclarationModifier::p_gnu_attribute_section_name};
13765 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13766 using bind = Desc<SgDeclarationModifier, std::string SgDeclarationModifier::*, &SgDeclarationModifier::p_gnu_attribute_section_name>;
13767};
13768template <> struct describe_field_t<SgDeclarationModifier,SgDeclarationModifier::gnu_declaration_visability_enum,&SgDeclarationModifier::p_gnu_attribute_visability> {
13771 static constexpr size_t position{5};
13772 static constexpr char const * const name{"gnu_attribute_visability"};
13773 static constexpr char const * const typestr{"SgDeclarationModifier::gnu_declaration_visability_enum"};
13774 static constexpr bool traverse{false};
13775 static constexpr auto mbr_ptr{&SgDeclarationModifier::p_gnu_attribute_visability};
13776 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13777 using bind = Desc<SgDeclarationModifier, SgDeclarationModifier::gnu_declaration_visability_enum SgDeclarationModifier::*, &SgDeclarationModifier::p_gnu_attribute_visability>;
13778};
13779template <> struct describe_field_t<SgDeclarationModifier,std::string,&SgDeclarationModifier::p_microsoft_uuid_string> {
13781 using field_type = std::string;
13782 static constexpr size_t position{6};
13783 static constexpr char const * const name{"microsoft_uuid_string"};
13784 static constexpr char const * const typestr{"std::string"};
13785 static constexpr bool traverse{false};
13786 static constexpr auto mbr_ptr{&SgDeclarationModifier::p_microsoft_uuid_string};
13787 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13788 using bind = Desc<SgDeclarationModifier, std::string SgDeclarationModifier::*, &SgDeclarationModifier::p_microsoft_uuid_string>;
13789};
13790template <> struct describe_field_t<SgDeclarationModifier,std::string,&SgDeclarationModifier::p_microsoft_property_get_function_name> {
13792 using field_type = std::string;
13793 static constexpr size_t position{7};
13794 static constexpr char const * const name{"microsoft_property_get_function_name"};
13795 static constexpr char const * const typestr{"std::string"};
13796 static constexpr bool traverse{false};
13797 static constexpr auto mbr_ptr{&SgDeclarationModifier::p_microsoft_property_get_function_name};
13798 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13799 using bind = Desc<SgDeclarationModifier, std::string SgDeclarationModifier::*, &SgDeclarationModifier::p_microsoft_property_get_function_name>;
13800};
13801template <> struct describe_field_t<SgDeclarationModifier,std::string,&SgDeclarationModifier::p_microsoft_property_put_function_name> {
13803 using field_type = std::string;
13804 static constexpr size_t position{8};
13805 static constexpr char const * const name{"microsoft_property_put_function_name"};
13806 static constexpr char const * const typestr{"std::string"};
13807 static constexpr bool traverse{false};
13808 static constexpr auto mbr_ptr{&SgDeclarationModifier::p_microsoft_property_put_function_name};
13809 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13810 using bind = Desc<SgDeclarationModifier, std::string SgDeclarationModifier::*, &SgDeclarationModifier::p_microsoft_property_put_function_name>;
13811};
13821template <> struct node_from_variant_t<364> { using type = SgDeclarationModifier; };
13822
13823// Class: DeclarationScope
13825 using node = SgDeclarationScope;
13826 using base = SgScopeStatement;
13827 static constexpr char const * const name{"DeclarationScope"};
13828 static constexpr unsigned long variant{365};
13829 static constexpr bool concrete{true};
13830 using subclasses_t = mp::List<>;
13831 using fields_t = mp::List<>;
13832};
13833template <> struct node_from_variant_t<365> { using type = SgDeclarationScope; };
13834
13835// Class: DeclarationStatement
13838 using field_type = unsigned int;
13839 static constexpr size_t position{0};
13840 static constexpr char const * const name{"decl_attributes"};
13841 static constexpr char const * const typestr{"unsigned int"};
13842 static constexpr bool traverse{false};
13843 static constexpr auto mbr_ptr{&SgDeclarationStatement::p_decl_attributes};
13844 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13845 using bind = Desc<SgDeclarationStatement, unsigned int SgDeclarationStatement::*, &SgDeclarationStatement::p_decl_attributes>;
13846};
13849 using field_type = std::string;
13850 static constexpr size_t position{1};
13851 static constexpr char const * const name{"linkage"};
13852 static constexpr char const * const typestr{"std::string"};
13853 static constexpr bool traverse{false};
13854 static constexpr auto mbr_ptr{&SgDeclarationStatement::p_linkage};
13855 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13856 using bind = Desc<SgDeclarationStatement, std::string SgDeclarationStatement::*, &SgDeclarationStatement::p_linkage>;
13857};
13861 static constexpr size_t position{2};
13862 static constexpr char const * const name{"declarationModifier"};
13863 static constexpr char const * const typestr{"SgDeclarationModifier"};
13864 static constexpr bool traverse{false};
13865 static constexpr auto mbr_ptr{&SgDeclarationStatement::p_declarationModifier};
13866 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13867 using bind = Desc<SgDeclarationStatement, SgDeclarationModifier SgDeclarationStatement::*, &SgDeclarationStatement::p_declarationModifier>;
13868};
13871 using field_type = bool;
13872 static constexpr size_t position{3};
13873 static constexpr char const * const name{"nameOnly"};
13874 static constexpr char const * const typestr{"bool"};
13875 static constexpr bool traverse{false};
13876 static constexpr auto mbr_ptr{&SgDeclarationStatement::p_nameOnly};
13877 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13878 using bind = Desc<SgDeclarationStatement, bool SgDeclarationStatement::*, &SgDeclarationStatement::p_nameOnly>;
13879};
13882 using field_type = bool;
13883 static constexpr size_t position{4};
13884 static constexpr char const * const name{"forward"};
13885 static constexpr char const * const typestr{"bool"};
13886 static constexpr bool traverse{false};
13887 static constexpr auto mbr_ptr{&SgDeclarationStatement::p_forward};
13888 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13889 using bind = Desc<SgDeclarationStatement, bool SgDeclarationStatement::*, &SgDeclarationStatement::p_forward>;
13890};
13893 using field_type = bool;
13894 static constexpr size_t position{5};
13895 static constexpr char const * const name{"externBrace"};
13896 static constexpr char const * const typestr{"bool"};
13897 static constexpr bool traverse{false};
13898 static constexpr auto mbr_ptr{&SgDeclarationStatement::p_externBrace};
13899 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13900 using bind = Desc<SgDeclarationStatement, bool SgDeclarationStatement::*, &SgDeclarationStatement::p_externBrace>;
13901};
13904 using field_type = bool;
13905 static constexpr size_t position{6};
13906 static constexpr char const * const name{"skipElaborateType"};
13907 static constexpr char const * const typestr{"bool"};
13908 static constexpr bool traverse{false};
13909 static constexpr auto mbr_ptr{&SgDeclarationStatement::p_skipElaborateType};
13910 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13911 using bind = Desc<SgDeclarationStatement, bool SgDeclarationStatement::*, &SgDeclarationStatement::p_skipElaborateType>;
13912};
13916 static constexpr size_t position{7};
13917 static constexpr char const * const name{"definingDeclaration"};
13918 static constexpr char const * const typestr{"SgDeclarationStatement*"};
13919 static constexpr bool traverse{false};
13920 static constexpr auto mbr_ptr{&SgDeclarationStatement::p_definingDeclaration};
13921 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13922 using bind = Desc<SgDeclarationStatement, SgDeclarationStatement* SgDeclarationStatement::*, &SgDeclarationStatement::p_definingDeclaration>;
13923};
13927 static constexpr size_t position{8};
13928 static constexpr char const * const name{"firstNondefiningDeclaration"};
13929 static constexpr char const * const typestr{"SgDeclarationStatement*"};
13930 static constexpr bool traverse{false};
13931 static constexpr auto mbr_ptr{&SgDeclarationStatement::p_firstNondefiningDeclaration};
13932 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13933 using bind = Desc<SgDeclarationStatement, SgDeclarationStatement* SgDeclarationStatement::*, &SgDeclarationStatement::p_firstNondefiningDeclaration>;
13934};
13935template <> struct describe_field_t<SgDeclarationStatement,SgQualifiedNamePtrList,&SgDeclarationStatement::p_qualifiedNameList> {
13937 using field_type = SgQualifiedNamePtrList;
13938 static constexpr size_t position{9};
13939 static constexpr char const * const name{"qualifiedNameList"};
13940 static constexpr char const * const typestr{"SgQualifiedNamePtrList"};
13941 static constexpr bool traverse{false};
13942 static constexpr auto mbr_ptr{&SgDeclarationStatement::p_qualifiedNameList};
13943 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13944 using bind = Desc<SgDeclarationStatement, SgQualifiedNamePtrList SgDeclarationStatement::*, &SgDeclarationStatement::p_qualifiedNameList>;
13945};
13946template <> struct describe_field_t<SgDeclarationStatement,std::string,&SgDeclarationStatement::p_binding_label> {
13948 using field_type = std::string;
13949 static constexpr size_t position{10};
13950 static constexpr char const * const name{"binding_label"};
13951 static constexpr char const * const typestr{"std::string"};
13952 static constexpr bool traverse{false};
13953 static constexpr auto mbr_ptr{&SgDeclarationStatement::p_binding_label};
13954 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13955 using bind = Desc<SgDeclarationStatement, std::string SgDeclarationStatement::*, &SgDeclarationStatement::p_binding_label>;
13956};
13957template <> struct describe_field_t<SgDeclarationStatement,SgDeclarationScope*,&SgDeclarationStatement::p_declarationScope> {
13960 static constexpr size_t position{11};
13961 static constexpr char const * const name{"declarationScope"};
13962 static constexpr char const * const typestr{"SgDeclarationScope*"};
13963 static constexpr bool traverse{false};
13964 static constexpr auto mbr_ptr{&SgDeclarationStatement::p_declarationScope};
13965 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13966 using bind = Desc<SgDeclarationStatement, SgDeclarationScope* SgDeclarationStatement::*, &SgDeclarationStatement::p_declarationScope>;
13967};
13968template <> struct describe_field_t<SgDeclarationStatement,bool,&SgDeclarationStatement::p_unparse_template_ast> {
13970 using field_type = bool;
13971 static constexpr size_t position{12};
13972 static constexpr char const * const name{"unparse_template_ast"};
13973 static constexpr char const * const typestr{"bool"};
13974 static constexpr bool traverse{false};
13975 static constexpr auto mbr_ptr{&SgDeclarationStatement::p_unparse_template_ast};
13976 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13977 using bind = Desc<SgDeclarationStatement, bool SgDeclarationStatement::*, &SgDeclarationStatement::p_unparse_template_ast>;
13978};
13979template <> struct describe_field_t<SgDeclarationStatement,SgExprListExp*,&SgDeclarationStatement::p_adaAspects> {
13981 using field_type = SgExprListExp*;
13982 static constexpr size_t position{13};
13983 static constexpr char const * const name{"adaAspects"};
13984 static constexpr char const * const typestr{"SgExprListExp*"};
13985 static constexpr bool traverse{false};
13986 static constexpr auto mbr_ptr{&SgDeclarationStatement::p_adaAspects};
13987 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
13988 using bind = Desc<SgDeclarationStatement, SgExprListExp* SgDeclarationStatement::*, &SgDeclarationStatement::p_adaAspects>;
13989};
13992 using base = SgStatement;
13993 static constexpr char const * const name{"DeclarationStatement"};
13994 static constexpr unsigned long variant{366};
13995 static constexpr bool concrete{false};
13996 using subclasses_t = mp::List<SgFunctionParameterList, SgVariableDeclaration, SgVariableDefinition, SgClinkageDeclarationStatement, SgEnumDeclaration, SgAsmStmt, SgAttributeSpecificationStatement, SgFormatStatement, SgTemplateDeclaration, SgTemplateInstantiationDirectiveStatement, SgUseStatement, SgParameterStatement, SgNamespaceDeclarationStatement, SgEquivalenceStatement, SgInterfaceStatement, SgNamespaceAliasDeclarationStatement, SgCommonBlock, SgTypedefDeclaration, SgStatementFunctionStatement, SgCtorInitializerList, SgPragmaDeclaration, SgUsingDirectiveStatement, SgClassDeclaration, SgImplicitStatement, SgUsingDeclarationStatement, SgNamelistStatement, SgImportStatement, SgFunctionDeclaration, SgContainsStatement, SgC_PreprocessorDirectiveStatement, SgOmpThreadprivateStatement, SgFortranIncludeLine, SgJavaImportStatement, SgJavaPackageStatement, SgStmtDeclarationStatement, SgStaticAssertionDeclaration, SgOmpDeclareSimdStatement, SgMicrosoftAttributeDeclaration, SgJovialCompoolStatement, SgJovialDirectiveStatement, SgJovialDefineDeclaration, SgJovialLabelDeclaration, SgJovialOverlayDeclaration, SgNonrealDecl, SgEmptyDeclaration, SgAdaPackageBodyDecl, SgAdaPackageSpecDecl, SgAdaRenamingDecl, SgAdaTaskSpecDecl, SgAdaTaskBodyDecl, SgAdaTaskTypeDecl, SgAdaProtectedSpecDecl, SgAdaProtectedBodyDecl, SgAdaProtectedTypeDecl, SgAdaRepresentationClause, SgAdaComponentClause, SgAdaAttributeClause, SgAdaEnumRepresentationClause, SgAdaGenericDecl, SgAdaFormalTypeDecl, SgAdaDiscriminatedTypeDecl, SgAdaGenericInstanceDecl, SgAdaFormalPackageDecl, SgAdaParameterList, SgAdaVariantDecl>;
13998};
13999template <> struct node_from_variant_t<366> { using type = SgDeclarationStatement; };
14000
14001// Class: DeclType
14002template <> struct describe_field_t<SgDeclType,SgExpression*,&SgDeclType::p_base_expression> {
14003 using parent = SgDeclType;
14004 using field_type = SgExpression*;
14005 static constexpr size_t position{0};
14006 static constexpr char const * const name{"base_expression"};
14007 static constexpr char const * const typestr{"SgExpression*"};
14008 static constexpr bool traverse{false};
14009 static constexpr auto mbr_ptr{&SgDeclType::p_base_expression};
14010 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14011 using bind = Desc<SgDeclType, SgExpression* SgDeclType::*, &SgDeclType::p_base_expression>;
14012};
14013template <> struct describe_field_t<SgDeclType,SgType*,&SgDeclType::p_base_type> {
14014 using parent = SgDeclType;
14015 using field_type = SgType*;
14016 static constexpr size_t position{1};
14017 static constexpr char const * const name{"base_type"};
14018 static constexpr char const * const typestr{"SgType*"};
14019 static constexpr bool traverse{false};
14020 static constexpr auto mbr_ptr{&SgDeclType::p_base_type};
14021 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14022 using bind = Desc<SgDeclType, SgType* SgDeclType::*, &SgDeclType::p_base_type>;
14023};
14024template <> struct describe_node_t<SgDeclType> {
14025 using node = SgDeclType;
14026 using base = SgType;
14027 static constexpr char const * const name{"DeclType"};
14028 static constexpr unsigned long variant{367};
14029 static constexpr bool concrete{true};
14030 using subclasses_t = mp::List<>;
14032};
14033template <> struct node_from_variant_t<367> { using type = SgDeclType; };
14034
14035// Class: DefaultOptionStmt
14038 using field_type = SgStatement*;
14039 static constexpr size_t position{0};
14040 static constexpr char const * const name{"body"};
14041 static constexpr char const * const typestr{"SgStatement*"};
14042 static constexpr bool traverse{true};
14043 static constexpr auto mbr_ptr{&SgDefaultOptionStmt::p_body};
14044 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14045 using bind = Desc<SgDefaultOptionStmt, SgStatement* SgDefaultOptionStmt::*, &SgDefaultOptionStmt::p_body>;
14046};
14047template <> struct describe_field_t<SgDefaultOptionStmt,std::string,&SgDefaultOptionStmt::p_default_construct_name> {
14049 using field_type = std::string;
14050 static constexpr size_t position{1};
14051 static constexpr char const * const name{"default_construct_name"};
14052 static constexpr char const * const typestr{"std::string"};
14053 static constexpr bool traverse{false};
14054 static constexpr auto mbr_ptr{&SgDefaultOptionStmt::p_default_construct_name};
14055 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14056 using bind = Desc<SgDefaultOptionStmt, std::string SgDefaultOptionStmt::*, &SgDefaultOptionStmt::p_default_construct_name>;
14057};
14058template <> struct describe_field_t<SgDefaultOptionStmt,bool,&SgDefaultOptionStmt::p_has_fall_through> {
14060 using field_type = bool;
14061 static constexpr size_t position{2};
14062 static constexpr char const * const name{"has_fall_through"};
14063 static constexpr char const * const typestr{"bool"};
14064 static constexpr bool traverse{false};
14065 static constexpr auto mbr_ptr{&SgDefaultOptionStmt::p_has_fall_through};
14066 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14067 using bind = Desc<SgDefaultOptionStmt, bool SgDefaultOptionStmt::*, &SgDefaultOptionStmt::p_has_fall_through>;
14068};
14070 using node = SgDefaultOptionStmt;
14071 using base = SgStatement;
14072 static constexpr char const * const name{"DefaultOptionStmt"};
14073 static constexpr unsigned long variant{368};
14074 static constexpr bool concrete{true};
14075 using subclasses_t = mp::List<>;
14077};
14078template <> struct node_from_variant_t<368> { using type = SgDefaultOptionStmt; };
14079
14080// Class: DefaultSymbol
14081template <> struct describe_field_t<SgDefaultSymbol,SgType*,&SgDefaultSymbol::p_type> {
14082 using parent = SgDefaultSymbol;
14083 using field_type = SgType*;
14084 static constexpr size_t position{0};
14085 static constexpr char const * const name{"type"};
14086 static constexpr char const * const typestr{"SgType*"};
14087 static constexpr bool traverse{false};
14088 static constexpr auto mbr_ptr{&SgDefaultSymbol::p_type};
14089 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14090 using bind = Desc<SgDefaultSymbol, SgType* SgDefaultSymbol::*, &SgDefaultSymbol::p_type>;
14091};
14093 using node = SgDefaultSymbol;
14094 using base = SgSymbol;
14095 static constexpr char const * const name{"DefaultSymbol"};
14096 static constexpr unsigned long variant{369};
14097 static constexpr bool concrete{true};
14098 using subclasses_t = mp::List<>;
14100};
14101template <> struct node_from_variant_t<369> { using type = SgDefaultSymbol; };
14102
14103// Class: DefineDirectiveStatement
14107 static constexpr char const * const name{"DefineDirectiveStatement"};
14108 static constexpr unsigned long variant{370};
14109 static constexpr bool concrete{true};
14110 using subclasses_t = mp::List<>;
14111 using fields_t = mp::List<>;
14112};
14113template <> struct node_from_variant_t<370> { using type = SgDefineDirectiveStatement; };
14114
14115// Class: DeleteExp
14117 using parent = SgDeleteExp;
14118 using field_type = SgExpression*;
14119 static constexpr size_t position{0};
14120 static constexpr char const * const name{"variable"};
14121 static constexpr char const * const typestr{"SgExpression*"};
14122 static constexpr bool traverse{true};
14123 static constexpr auto mbr_ptr{&SgDeleteExp::p_variable};
14124 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14125 using bind = Desc<SgDeleteExp, SgExpression* SgDeleteExp::*, &SgDeleteExp::p_variable>;
14126};
14128 using parent = SgDeleteExp;
14129 using field_type = short;
14130 static constexpr size_t position{1};
14131 static constexpr char const * const name{"is_array"};
14132 static constexpr char const * const typestr{"short"};
14133 static constexpr bool traverse{false};
14134 static constexpr auto mbr_ptr{&SgDeleteExp::p_is_array};
14135 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14136 using bind = Desc<SgDeleteExp, short SgDeleteExp::*, &SgDeleteExp::p_is_array>;
14137};
14139 using parent = SgDeleteExp;
14140 using field_type = short;
14141 static constexpr size_t position{2};
14142 static constexpr char const * const name{"need_global_specifier"};
14143 static constexpr char const * const typestr{"short"};
14144 static constexpr bool traverse{false};
14145 static constexpr auto mbr_ptr{&SgDeleteExp::p_need_global_specifier};
14146 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14147 using bind = Desc<SgDeleteExp, short SgDeleteExp::*, &SgDeleteExp::p_need_global_specifier>;
14148};
14149template <> struct describe_field_t<SgDeleteExp,SgFunctionDeclaration*,&SgDeleteExp::p_deleteOperatorDeclaration> {
14150 using parent = SgDeleteExp;
14152 static constexpr size_t position{3};
14153 static constexpr char const * const name{"deleteOperatorDeclaration"};
14154 static constexpr char const * const typestr{"SgFunctionDeclaration*"};
14155 static constexpr bool traverse{false};
14156 static constexpr auto mbr_ptr{&SgDeleteExp::p_deleteOperatorDeclaration};
14157 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14158 using bind = Desc<SgDeleteExp, SgFunctionDeclaration* SgDeleteExp::*, &SgDeleteExp::p_deleteOperatorDeclaration>;
14159};
14160template <> struct describe_node_t<SgDeleteExp> {
14161 using node = SgDeleteExp;
14162 using base = SgExpression;
14163 static constexpr char const * const name{"DeleteExp"};
14164 static constexpr unsigned long variant{371};
14165 static constexpr bool concrete{true};
14166 using subclasses_t = mp::List<>;
14168};
14169template <> struct node_from_variant_t<371> { using type = SgDeleteExp; };
14170
14171// Class: DerivedTypeStatement
14172template <> struct describe_field_t<SgDerivedTypeStatement,SgLabelRefExp*,&SgDerivedTypeStatement::p_end_numeric_label> {
14174 using field_type = SgLabelRefExp*;
14175 static constexpr size_t position{0};
14176 static constexpr char const * const name{"end_numeric_label"};
14177 static constexpr char const * const typestr{"SgLabelRefExp*"};
14178 static constexpr bool traverse{false};
14179 static constexpr auto mbr_ptr{&SgDerivedTypeStatement::p_end_numeric_label};
14180 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14181 using bind = Desc<SgDerivedTypeStatement, SgLabelRefExp* SgDerivedTypeStatement::*, &SgDerivedTypeStatement::p_end_numeric_label>;
14182};
14185 using base = SgClassDeclaration;
14186 static constexpr char const * const name{"DerivedTypeStatement"};
14187 static constexpr unsigned long variant{372};
14188 static constexpr bool concrete{true};
14189 using subclasses_t = mp::List<>;
14191};
14192template <> struct node_from_variant_t<372> { using type = SgDerivedTypeStatement; };
14193
14194// Class: DesignatedInitializer
14195template <> struct describe_field_t<SgDesignatedInitializer,SgExprListExp*,&SgDesignatedInitializer::p_designatorList> {
14197 using field_type = SgExprListExp*;
14198 static constexpr size_t position{0};
14199 static constexpr char const * const name{"designatorList"};
14200 static constexpr char const * const typestr{"SgExprListExp*"};
14201 static constexpr bool traverse{true};
14202 static constexpr auto mbr_ptr{&SgDesignatedInitializer::p_designatorList};
14203 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14204 using bind = Desc<SgDesignatedInitializer, SgExprListExp* SgDesignatedInitializer::*, &SgDesignatedInitializer::p_designatorList>;
14205};
14206template <> struct describe_field_t<SgDesignatedInitializer,SgInitializer*,&SgDesignatedInitializer::p_memberInit> {
14208 using field_type = SgInitializer*;
14209 static constexpr size_t position{1};
14210 static constexpr char const * const name{"memberInit"};
14211 static constexpr char const * const typestr{"SgInitializer*"};
14212 static constexpr bool traverse{true};
14213 static constexpr auto mbr_ptr{&SgDesignatedInitializer::p_memberInit};
14214 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14215 using bind = Desc<SgDesignatedInitializer, SgInitializer* SgDesignatedInitializer::*, &SgDesignatedInitializer::p_memberInit>;
14216};
14219 using base = SgInitializer;
14220 static constexpr char const * const name{"DesignatedInitializer"};
14221 static constexpr unsigned long variant{373};
14222 static constexpr bool concrete{true};
14223 using subclasses_t = mp::List<>;
14225};
14226template <> struct node_from_variant_t<373> { using type = SgDesignatedInitializer; };
14227
14228// Class: DictionaryComprehension
14229template <> struct describe_field_t<SgDictionaryComprehension,SgKeyDatumPair*,&SgDictionaryComprehension::p_element> {
14231 using field_type = SgKeyDatumPair*;
14232 static constexpr size_t position{0};
14233 static constexpr char const * const name{"element"};
14234 static constexpr char const * const typestr{"SgKeyDatumPair*"};
14235 static constexpr bool traverse{true};
14236 static constexpr auto mbr_ptr{&SgDictionaryComprehension::p_element};
14237 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14238 using bind = Desc<SgDictionaryComprehension, SgKeyDatumPair* SgDictionaryComprehension::*, &SgDictionaryComprehension::p_element>;
14239};
14240template <> struct describe_field_t<SgDictionaryComprehension,SgExprListExp*,&SgDictionaryComprehension::p_generators> {
14242 using field_type = SgExprListExp*;
14243 static constexpr size_t position{1};
14244 static constexpr char const * const name{"generators"};
14245 static constexpr char const * const typestr{"SgExprListExp*"};
14246 static constexpr bool traverse{true};
14247 static constexpr auto mbr_ptr{&SgDictionaryComprehension::p_generators};
14248 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14249 using bind = Desc<SgDictionaryComprehension, SgExprListExp* SgDictionaryComprehension::*, &SgDictionaryComprehension::p_generators>;
14250};
14253 using base = SgExpression;
14254 static constexpr char const * const name{"DictionaryComprehension"};
14255 static constexpr unsigned long variant{374};
14256 static constexpr bool concrete{true};
14257 using subclasses_t = mp::List<>;
14259};
14260template <> struct node_from_variant_t<374> { using type = SgDictionaryComprehension; };
14261
14262// Class: DictionaryExp
14263template <> struct describe_field_t<SgDictionaryExp,SgKeyDatumPairPtrList,&SgDictionaryExp::p_key_datum_pairs> {
14264 using parent = SgDictionaryExp;
14265 using field_type = SgKeyDatumPairPtrList;
14266 static constexpr size_t position{0};
14267 static constexpr char const * const name{"key_datum_pairs"};
14268 static constexpr char const * const typestr{"SgKeyDatumPairPtrList"};
14269 static constexpr bool traverse{true};
14270 static constexpr auto mbr_ptr{&SgDictionaryExp::p_key_datum_pairs};
14271 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14272 using bind = Desc<SgDictionaryExp, SgKeyDatumPairPtrList SgDictionaryExp::*, &SgDictionaryExp::p_key_datum_pairs>;
14273};
14275 using node = SgDictionaryExp;
14276 using base = SgExpression;
14277 static constexpr char const * const name{"DictionaryExp"};
14278 static constexpr unsigned long variant{375};
14279 static constexpr bool concrete{true};
14280 using subclasses_t = mp::List<>;
14282};
14283template <> struct node_from_variant_t<375> { using type = SgDictionaryExp; };
14284
14285// Class: DimensionObject
14286template <> struct describe_field_t<SgDimensionObject,SgInitializedName*,&SgDimensionObject::p_array> {
14287 using parent = SgDimensionObject;
14289 static constexpr size_t position{0};
14290 static constexpr char const * const name{"array"};
14291 static constexpr char const * const typestr{"SgInitializedName*"};
14292 static constexpr bool traverse{false};
14293 static constexpr auto mbr_ptr{&SgDimensionObject::p_array};
14294 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14295 using bind = Desc<SgDimensionObject, SgInitializedName* SgDimensionObject::*, &SgDimensionObject::p_array>;
14296};
14297template <> struct describe_field_t<SgDimensionObject,SgExprListExp*,&SgDimensionObject::p_shape> {
14298 using parent = SgDimensionObject;
14299 using field_type = SgExprListExp*;
14300 static constexpr size_t position{1};
14301 static constexpr char const * const name{"shape"};
14302 static constexpr char const * const typestr{"SgExprListExp*"};
14303 static constexpr bool traverse{false};
14304 static constexpr auto mbr_ptr{&SgDimensionObject::p_shape};
14305 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14306 using bind = Desc<SgDimensionObject, SgExprListExp* SgDimensionObject::*, &SgDimensionObject::p_shape>;
14307};
14309 using node = SgDimensionObject;
14310 using base = SgSupport;
14311 static constexpr char const * const name{"DimensionObject"};
14312 static constexpr unsigned long variant{376};
14313 static constexpr bool concrete{true};
14314 using subclasses_t = mp::List<>;
14316};
14317template <> struct node_from_variant_t<376> { using type = SgDimensionObject; };
14318
14319// Class: DirectedGraphEdge
14321 using node = SgDirectedGraphEdge;
14322 using base = SgGraphEdge;
14323 static constexpr char const * const name{"DirectedGraphEdge"};
14324 static constexpr unsigned long variant{378};
14325 static constexpr bool concrete{true};
14326 using subclasses_t = mp::List<>;
14327 using fields_t = mp::List<>;
14328};
14329template <> struct node_from_variant_t<378> { using type = SgDirectedGraphEdge; };
14330
14331// Class: Directory
14332template <> struct describe_field_t<SgDirectory,std::string,&SgDirectory::p_name> {
14333 using parent = SgDirectory;
14334 using field_type = std::string;
14335 static constexpr size_t position{0};
14336 static constexpr char const * const name{"name"};
14337 static constexpr char const * const typestr{"std::string"};
14338 static constexpr bool traverse{false};
14339 static constexpr auto mbr_ptr{&SgDirectory::p_name};
14340 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14341 using bind = Desc<SgDirectory, std::string SgDirectory::*, &SgDirectory::p_name>;
14342};
14343template <> struct describe_field_t<SgDirectory,SgFileList*,&SgDirectory::p_fileList> {
14344 using parent = SgDirectory;
14345 using field_type = SgFileList*;
14346 static constexpr size_t position{1};
14347 static constexpr char const * const name{"fileList"};
14348 static constexpr char const * const typestr{"SgFileList*"};
14349 static constexpr bool traverse{true};
14350 static constexpr auto mbr_ptr{&SgDirectory::p_fileList};
14351 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14352 using bind = Desc<SgDirectory, SgFileList* SgDirectory::*, &SgDirectory::p_fileList>;
14353};
14354template <> struct describe_field_t<SgDirectory,SgDirectoryList*,&SgDirectory::p_directoryList> {
14355 using parent = SgDirectory;
14356 using field_type = SgDirectoryList*;
14357 static constexpr size_t position{2};
14358 static constexpr char const * const name{"directoryList"};
14359 static constexpr char const * const typestr{"SgDirectoryList*"};
14360 static constexpr bool traverse{true};
14361 static constexpr auto mbr_ptr{&SgDirectory::p_directoryList};
14362 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14363 using bind = Desc<SgDirectory, SgDirectoryList* SgDirectory::*, &SgDirectory::p_directoryList>;
14364};
14365template <> struct describe_field_t<SgDirectory,AstAttributeMechanism*,&SgDirectory::p_attributeMechanism> {
14366 using parent = SgDirectory;
14368 static constexpr size_t position{3};
14369 static constexpr char const * const name{"attributeMechanism"};
14370 static constexpr char const * const typestr{"AstAttributeMechanism*"};
14371 static constexpr bool traverse{false};
14372 static constexpr auto mbr_ptr{&SgDirectory::p_attributeMechanism};
14373 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14374 using bind = Desc<SgDirectory, AstAttributeMechanism* SgDirectory::*, &SgDirectory::p_attributeMechanism>;
14375};
14376template <> struct describe_node_t<SgDirectory> {
14377 using node = SgDirectory;
14378 using base = SgSupport;
14379 static constexpr char const * const name{"Directory"};
14380 static constexpr unsigned long variant{380};
14381 static constexpr bool concrete{true};
14382 using subclasses_t = mp::List<>;
14384};
14385template <> struct node_from_variant_t<380> { using type = SgDirectory; };
14386
14387// Class: DirectoryList
14388template <> struct describe_field_t<SgDirectoryList,SgDirectoryPtrList,&SgDirectoryList::p_listOfDirectories> {
14389 using parent = SgDirectoryList;
14390 using field_type = SgDirectoryPtrList;
14391 static constexpr size_t position{0};
14392 static constexpr char const * const name{"listOfDirectories"};
14393 static constexpr char const * const typestr{"SgDirectoryPtrList"};
14394 static constexpr bool traverse{true};
14395 static constexpr auto mbr_ptr{&SgDirectoryList::p_listOfDirectories};
14396 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14397 using bind = Desc<SgDirectoryList, SgDirectoryPtrList SgDirectoryList::*, &SgDirectoryList::p_listOfDirectories>;
14398};
14400 using node = SgDirectoryList;
14401 using base = SgSupport;
14402 static constexpr char const * const name{"DirectoryList"};
14403 static constexpr unsigned long variant{381};
14404 static constexpr bool concrete{true};
14405 using subclasses_t = mp::List<>;
14407};
14408template <> struct node_from_variant_t<381> { using type = SgDirectoryList; };
14409
14410// Class: DivAssignOp
14411template <> struct describe_node_t<SgDivAssignOp> {
14412 using node = SgDivAssignOp;
14413 using base = SgCompoundAssignOp;
14414 static constexpr char const * const name{"DivAssignOp"};
14415 static constexpr unsigned long variant{382};
14416 static constexpr bool concrete{true};
14417 using subclasses_t = mp::List<>;
14418 using fields_t = mp::List<>;
14419};
14420template <> struct node_from_variant_t<382> { using type = SgDivAssignOp; };
14421
14422// Class: DivideOp
14423template <> struct describe_node_t<SgDivideOp> {
14424 using node = SgDivideOp;
14425 using base = SgBinaryOp;
14426 static constexpr char const * const name{"DivideOp"};
14427 static constexpr unsigned long variant{383};
14428 static constexpr bool concrete{true};
14429 using subclasses_t = mp::List<>;
14430 using fields_t = mp::List<>;
14431};
14432template <> struct node_from_variant_t<383> { using type = SgDivideOp; };
14433
14434// Class: DoWhileStmt
14436 using parent = SgDoWhileStmt;
14437 using field_type = SgStatement*;
14438 static constexpr size_t position{0};
14439 static constexpr char const * const name{"body"};
14440 static constexpr char const * const typestr{"SgStatement*"};
14441 static constexpr bool traverse{true};
14442 static constexpr auto mbr_ptr{&SgDoWhileStmt::p_body};
14443 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14444 using bind = Desc<SgDoWhileStmt, SgStatement* SgDoWhileStmt::*, &SgDoWhileStmt::p_body>;
14445};
14447 using parent = SgDoWhileStmt;
14448 using field_type = SgStatement*;
14449 static constexpr size_t position{1};
14450 static constexpr char const * const name{"condition"};
14451 static constexpr char const * const typestr{"SgStatement*"};
14452 static constexpr bool traverse{true};
14453 static constexpr auto mbr_ptr{&SgDoWhileStmt::p_condition};
14454 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14455 using bind = Desc<SgDoWhileStmt, SgStatement* SgDoWhileStmt::*, &SgDoWhileStmt::p_condition>;
14456};
14457template <> struct describe_node_t<SgDoWhileStmt> {
14458 using node = SgDoWhileStmt;
14459 using base = SgScopeStatement;
14460 static constexpr char const * const name{"DoWhileStmt"};
14461 static constexpr unsigned long variant{384};
14462 static constexpr bool concrete{true};
14463 using subclasses_t = mp::List<>;
14465};
14466template <> struct node_from_variant_t<384> { using type = SgDoWhileStmt; };
14467
14468// Class: DotExp
14469template <> struct describe_node_t<SgDotExp> {
14470 using node = SgDotExp;
14471 using base = SgBinaryOp;
14472 static constexpr char const * const name{"DotExp"};
14473 static constexpr unsigned long variant{385};
14474 static constexpr bool concrete{true};
14475 using subclasses_t = mp::List<>;
14476 using fields_t = mp::List<>;
14477};
14478template <> struct node_from_variant_t<385> { using type = SgDotExp; };
14479
14480// Class: DotStarOp
14481template <> struct describe_node_t<SgDotStarOp> {
14482 using node = SgDotStarOp;
14483 using base = SgBinaryOp;
14484 static constexpr char const * const name{"DotStarOp"};
14485 static constexpr unsigned long variant{386};
14486 static constexpr bool concrete{true};
14487 using subclasses_t = mp::List<>;
14488 using fields_t = mp::List<>;
14489};
14490template <> struct node_from_variant_t<386> { using type = SgDotStarOp; };
14491
14492// Class: DoubleVal
14494 using parent = SgDoubleVal;
14495 using field_type = double;
14496 static constexpr size_t position{0};
14497 static constexpr char const * const name{"value"};
14498 static constexpr char const * const typestr{"double"};
14499 static constexpr bool traverse{false};
14500 static constexpr auto mbr_ptr{&SgDoubleVal::p_value};
14501 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14502 using bind = Desc<SgDoubleVal, double SgDoubleVal::*, &SgDoubleVal::p_value>;
14503};
14504template <> struct describe_field_t<SgDoubleVal,std::string,&SgDoubleVal::p_valueString> {
14505 using parent = SgDoubleVal;
14506 using field_type = std::string;
14507 static constexpr size_t position{1};
14508 static constexpr char const * const name{"valueString"};
14509 static constexpr char const * const typestr{"std::string"};
14510 static constexpr bool traverse{false};
14511 static constexpr auto mbr_ptr{&SgDoubleVal::p_valueString};
14512 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14513 using bind = Desc<SgDoubleVal, std::string SgDoubleVal::*, &SgDoubleVal::p_valueString>;
14514};
14515template <> struct describe_node_t<SgDoubleVal> {
14516 using node = SgDoubleVal;
14517 using base = SgValueExp;
14518 static constexpr char const * const name{"DoubleVal"};
14519 static constexpr unsigned long variant{387};
14520 static constexpr bool concrete{true};
14521 using subclasses_t = mp::List<>;
14523};
14524template <> struct node_from_variant_t<387> { using type = SgDoubleVal; };
14525
14526// Class: ElaboratedTypeModifier
14527template <> struct describe_field_t<SgElaboratedTypeModifier,SgElaboratedTypeModifier::elaborated_type_modifier_enum,&SgElaboratedTypeModifier::p_modifier> {
14530 static constexpr size_t position{0};
14531 static constexpr char const * const name{"modifier"};
14532 static constexpr char const * const typestr{"SgElaboratedTypeModifier::elaborated_type_modifier_enum"};
14533 static constexpr bool traverse{false};
14534 static constexpr auto mbr_ptr{&SgElaboratedTypeModifier::p_modifier};
14535 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14536 using bind = Desc<SgElaboratedTypeModifier, SgElaboratedTypeModifier::elaborated_type_modifier_enum SgElaboratedTypeModifier::*, &SgElaboratedTypeModifier::p_modifier>;
14537};
14540 using base = SgModifier;
14541 static constexpr char const * const name{"ElaboratedTypeModifier"};
14542 static constexpr unsigned long variant{388};
14543 static constexpr bool concrete{true};
14544 using subclasses_t = mp::List<>;
14546};
14547template <> struct node_from_variant_t<388> { using type = SgElaboratedTypeModifier; };
14548
14549// Class: ElementwiseOp
14551 using node = SgElementwiseOp;
14552 using base = SgBinaryOp;
14553 static constexpr char const * const name{"ElementwiseOp"};
14554 static constexpr unsigned long variant{389};
14555 static constexpr bool concrete{false};
14557 using fields_t = mp::List<>;
14558};
14559template <> struct node_from_variant_t<389> { using type = SgElementwiseOp; };
14560
14561// Class: ElementwiseAddOp
14563 using node = SgElementwiseAddOp;
14564 using base = SgElementwiseOp;
14565 static constexpr char const * const name{"ElementwiseAddOp"};
14566 static constexpr unsigned long variant{390};
14567 static constexpr bool concrete{true};
14568 using subclasses_t = mp::List<>;
14569 using fields_t = mp::List<>;
14570};
14571template <> struct node_from_variant_t<390> { using type = SgElementwiseAddOp; };
14572
14573// Class: ElementwiseDivideOp
14576 using base = SgElementwiseOp;
14577 static constexpr char const * const name{"ElementwiseDivideOp"};
14578 static constexpr unsigned long variant{391};
14579 static constexpr bool concrete{true};
14580 using subclasses_t = mp::List<>;
14581 using fields_t = mp::List<>;
14582};
14583template <> struct node_from_variant_t<391> { using type = SgElementwiseDivideOp; };
14584
14585// Class: ElementwiseLeftDivideOp
14588 using base = SgElementwiseOp;
14589 static constexpr char const * const name{"ElementwiseLeftDivideOp"};
14590 static constexpr unsigned long variant{392};
14591 static constexpr bool concrete{true};
14592 using subclasses_t = mp::List<>;
14593 using fields_t = mp::List<>;
14594};
14595template <> struct node_from_variant_t<392> { using type = SgElementwiseLeftDivideOp; };
14596
14597// Class: ElementwiseMultiplyOp
14600 using base = SgElementwiseOp;
14601 static constexpr char const * const name{"ElementwiseMultiplyOp"};
14602 static constexpr unsigned long variant{393};
14603 static constexpr bool concrete{true};
14604 using subclasses_t = mp::List<>;
14605 using fields_t = mp::List<>;
14606};
14607template <> struct node_from_variant_t<393> { using type = SgElementwiseMultiplyOp; };
14608
14609// Class: ElementwisePowerOp
14611 using node = SgElementwisePowerOp;
14612 using base = SgElementwiseOp;
14613 static constexpr char const * const name{"ElementwisePowerOp"};
14614 static constexpr unsigned long variant{394};
14615 static constexpr bool concrete{true};
14616 using subclasses_t = mp::List<>;
14617 using fields_t = mp::List<>;
14618};
14619template <> struct node_from_variant_t<394> { using type = SgElementwisePowerOp; };
14620
14621// Class: ElementwiseSubtractOp
14624 using base = SgElementwiseOp;
14625 static constexpr char const * const name{"ElementwiseSubtractOp"};
14626 static constexpr unsigned long variant{395};
14627 static constexpr bool concrete{true};
14628 using subclasses_t = mp::List<>;
14629 using fields_t = mp::List<>;
14630};
14631template <> struct node_from_variant_t<395> { using type = SgElementwiseSubtractOp; };
14632
14633// Class: ElseDirectiveStatement
14637 static constexpr char const * const name{"ElseDirectiveStatement"};
14638 static constexpr unsigned long variant{396};
14639 static constexpr bool concrete{true};
14640 using subclasses_t = mp::List<>;
14641 using fields_t = mp::List<>;
14642};
14643template <> struct node_from_variant_t<396> { using type = SgElseDirectiveStatement; };
14644
14645// Class: ElseWhereStatement
14646template <> struct describe_field_t<SgElseWhereStatement,SgExpression*,&SgElseWhereStatement::p_condition> {
14648 using field_type = SgExpression*;
14649 static constexpr size_t position{0};
14650 static constexpr char const * const name{"condition"};
14651 static constexpr char const * const typestr{"SgExpression*"};
14652 static constexpr bool traverse{true};
14653 static constexpr auto mbr_ptr{&SgElseWhereStatement::p_condition};
14654 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14655 using bind = Desc<SgElseWhereStatement, SgExpression* SgElseWhereStatement::*, &SgElseWhereStatement::p_condition>;
14656};
14657template <> struct describe_field_t<SgElseWhereStatement,SgBasicBlock*,&SgElseWhereStatement::p_body> {
14659 using field_type = SgBasicBlock*;
14660 static constexpr size_t position{1};
14661 static constexpr char const * const name{"body"};
14662 static constexpr char const * const typestr{"SgBasicBlock*"};
14663 static constexpr bool traverse{true};
14664 static constexpr auto mbr_ptr{&SgElseWhereStatement::p_body};
14665 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14666 using bind = Desc<SgElseWhereStatement, SgBasicBlock* SgElseWhereStatement::*, &SgElseWhereStatement::p_body>;
14667};
14668template <> struct describe_field_t<SgElseWhereStatement,SgElseWhereStatement*,&SgElseWhereStatement::p_elsewhere> {
14671 static constexpr size_t position{2};
14672 static constexpr char const * const name{"elsewhere"};
14673 static constexpr char const * const typestr{"SgElseWhereStatement*"};
14674 static constexpr bool traverse{true};
14675 static constexpr auto mbr_ptr{&SgElseWhereStatement::p_elsewhere};
14676 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14677 using bind = Desc<SgElseWhereStatement, SgElseWhereStatement* SgElseWhereStatement::*, &SgElseWhereStatement::p_elsewhere>;
14678};
14680 using node = SgElseWhereStatement;
14681 using base = SgStatement;
14682 static constexpr char const * const name{"ElseWhereStatement"};
14683 static constexpr unsigned long variant{397};
14684 static constexpr bool concrete{true};
14685 using subclasses_t = mp::List<>;
14687};
14688template <> struct node_from_variant_t<397> { using type = SgElseWhereStatement; };
14689
14690// Class: ElseifDirectiveStatement
14694 static constexpr char const * const name{"ElseifDirectiveStatement"};
14695 static constexpr unsigned long variant{398};
14696 static constexpr bool concrete{true};
14697 using subclasses_t = mp::List<>;
14698 using fields_t = mp::List<>;
14699};
14700template <> struct node_from_variant_t<398> { using type = SgElseifDirectiveStatement; };
14701
14702// Class: EmptyDeclaration
14704 using node = SgEmptyDeclaration;
14706 static constexpr char const * const name{"EmptyDeclaration"};
14707 static constexpr unsigned long variant{399};
14708 static constexpr bool concrete{true};
14709 using subclasses_t = mp::List<>;
14710 using fields_t = mp::List<>;
14711};
14712template <> struct node_from_variant_t<399> { using type = SgEmptyDeclaration; };
14713
14714// Class: EmptyDirectiveStatement
14718 static constexpr char const * const name{"EmptyDirectiveStatement"};
14719 static constexpr unsigned long variant{400};
14720 static constexpr bool concrete{true};
14721 using subclasses_t = mp::List<>;
14722 using fields_t = mp::List<>;
14723};
14724template <> struct node_from_variant_t<400> { using type = SgEmptyDirectiveStatement; };
14725
14726// Class: EndfileStatement
14728 using node = SgEndfileStatement;
14729 using base = SgIOStatement;
14730 static constexpr char const * const name{"EndfileStatement"};
14731 static constexpr unsigned long variant{401};
14732 static constexpr bool concrete{true};
14733 using subclasses_t = mp::List<>;
14734 using fields_t = mp::List<>;
14735};
14736template <> struct node_from_variant_t<401> { using type = SgEndfileStatement; };
14737
14738// Class: EndifDirectiveStatement
14742 static constexpr char const * const name{"EndifDirectiveStatement"};
14743 static constexpr unsigned long variant{402};
14744 static constexpr bool concrete{true};
14745 using subclasses_t = mp::List<>;
14746 using fields_t = mp::List<>;
14747};
14748template <> struct node_from_variant_t<402> { using type = SgEndifDirectiveStatement; };
14749
14750// Class: EntryStatement
14751template <> struct describe_field_t<SgEntryStatement,SgInitializedName*,&SgEntryStatement::p_result_name> {
14752 using parent = SgEntryStatement;
14754 static constexpr size_t position{0};
14755 static constexpr char const * const name{"result_name"};
14756 static constexpr char const * const typestr{"SgInitializedName*"};
14757 static constexpr bool traverse{true};
14758 static constexpr auto mbr_ptr{&SgEntryStatement::p_result_name};
14759 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14760 using bind = Desc<SgEntryStatement, SgInitializedName* SgEntryStatement::*, &SgEntryStatement::p_result_name>;
14761};
14763 using node = SgEntryStatement;
14765 static constexpr char const * const name{"EntryStatement"};
14766 static constexpr unsigned long variant{403};
14767 static constexpr bool concrete{true};
14768 using subclasses_t = mp::List<>;
14770};
14771template <> struct node_from_variant_t<403> { using type = SgEntryStatement; };
14772
14773// Class: EnumDeclaration
14775 using parent = SgEnumDeclaration;
14776 using field_type = SgName;
14777 static constexpr size_t position{0};
14778 static constexpr char const * const name{"name"};
14779 static constexpr char const * const typestr{"SgName"};
14780 static constexpr bool traverse{false};
14781 static constexpr auto mbr_ptr{&SgEnumDeclaration::p_name};
14782 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14783 using bind = Desc<SgEnumDeclaration, SgName SgEnumDeclaration::*, &SgEnumDeclaration::p_name>;
14784};
14786 using parent = SgEnumDeclaration;
14787 using field_type = bool;
14788 static constexpr size_t position{1};
14789 static constexpr char const * const name{"embedded"};
14790 static constexpr char const * const typestr{"bool"};
14791 static constexpr bool traverse{false};
14792 static constexpr auto mbr_ptr{&SgEnumDeclaration::p_embedded};
14793 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14794 using bind = Desc<SgEnumDeclaration, bool SgEnumDeclaration::*, &SgEnumDeclaration::p_embedded>;
14795};
14797 using parent = SgEnumDeclaration;
14798 using field_type = SgEnumType*;
14799 static constexpr size_t position{2};
14800 static constexpr char const * const name{"type"};
14801 static constexpr char const * const typestr{"SgEnumType*"};
14802 static constexpr bool traverse{false};
14803 static constexpr auto mbr_ptr{&SgEnumDeclaration::p_type};
14804 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14805 using bind = Desc<SgEnumDeclaration, SgEnumType* SgEnumDeclaration::*, &SgEnumDeclaration::p_type>;
14806};
14807template <> struct describe_field_t<SgEnumDeclaration,SgType*,&SgEnumDeclaration::p_adaParentType> {
14808 using parent = SgEnumDeclaration;
14809 using field_type = SgType*;
14810 static constexpr size_t position{3};
14811 static constexpr char const * const name{"adaParentType"};
14812 static constexpr char const * const typestr{"SgType*"};
14813 static constexpr bool traverse{false};
14814 static constexpr auto mbr_ptr{&SgEnumDeclaration::p_adaParentType};
14815 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14816 using bind = Desc<SgEnumDeclaration, SgType* SgEnumDeclaration::*, &SgEnumDeclaration::p_adaParentType>;
14817};
14818template <> struct describe_field_t<SgEnumDeclaration,SgInitializedNamePtrList,&SgEnumDeclaration::p_enumerators> {
14819 using parent = SgEnumDeclaration;
14820 using field_type = SgInitializedNamePtrList;
14821 static constexpr size_t position{4};
14822 static constexpr char const * const name{"enumerators"};
14823 static constexpr char const * const typestr{"SgInitializedNamePtrList"};
14824 static constexpr bool traverse{true};
14825 static constexpr auto mbr_ptr{&SgEnumDeclaration::p_enumerators};
14826 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14827 using bind = Desc<SgEnumDeclaration, SgInitializedNamePtrList SgEnumDeclaration::*, &SgEnumDeclaration::p_enumerators>;
14828};
14830 using parent = SgEnumDeclaration;
14832 static constexpr size_t position{5};
14833 static constexpr char const * const name{"scope"};
14834 static constexpr char const * const typestr{"SgScopeStatement*"};
14835 static constexpr bool traverse{false};
14836 static constexpr auto mbr_ptr{&SgEnumDeclaration::p_scope};
14837 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14838 using bind = Desc<SgEnumDeclaration, SgScopeStatement* SgEnumDeclaration::*, &SgEnumDeclaration::p_scope>;
14839};
14840template <> struct describe_field_t<SgEnumDeclaration,bool,&SgEnumDeclaration::p_isUnNamed> {
14841 using parent = SgEnumDeclaration;
14842 using field_type = bool;
14843 static constexpr size_t position{6};
14844 static constexpr char const * const name{"isUnNamed"};
14845 static constexpr char const * const typestr{"bool"};
14846 static constexpr bool traverse{false};
14847 static constexpr auto mbr_ptr{&SgEnumDeclaration::p_isUnNamed};
14848 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14849 using bind = Desc<SgEnumDeclaration, bool SgEnumDeclaration::*, &SgEnumDeclaration::p_isUnNamed>;
14850};
14851template <> struct describe_field_t<SgEnumDeclaration,bool,&SgEnumDeclaration::p_isAutonomousDeclaration> {
14852 using parent = SgEnumDeclaration;
14853 using field_type = bool;
14854 static constexpr size_t position{7};
14855 static constexpr char const * const name{"isAutonomousDeclaration"};
14856 static constexpr char const * const typestr{"bool"};
14857 static constexpr bool traverse{false};
14858 static constexpr auto mbr_ptr{&SgEnumDeclaration::p_isAutonomousDeclaration};
14859 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14860 using bind = Desc<SgEnumDeclaration, bool SgEnumDeclaration::*, &SgEnumDeclaration::p_isAutonomousDeclaration>;
14861};
14862template <> struct describe_field_t<SgEnumDeclaration,SgType*,&SgEnumDeclaration::p_field_type> {
14863 using parent = SgEnumDeclaration;
14864 using field_type = SgType*;
14865 static constexpr size_t position{8};
14866 static constexpr char const * const name{"field_type"};
14867 static constexpr char const * const typestr{"SgType*"};
14868 static constexpr bool traverse{false};
14869 static constexpr auto mbr_ptr{&SgEnumDeclaration::p_field_type};
14870 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14871 using bind = Desc<SgEnumDeclaration, SgType* SgEnumDeclaration::*, &SgEnumDeclaration::p_field_type>;
14872};
14873template <> struct describe_field_t<SgEnumDeclaration,bool,&SgEnumDeclaration::p_isScopedEnum> {
14874 using parent = SgEnumDeclaration;
14875 using field_type = bool;
14876 static constexpr size_t position{9};
14877 static constexpr char const * const name{"isScopedEnum"};
14878 static constexpr char const * const typestr{"bool"};
14879 static constexpr bool traverse{false};
14880 static constexpr auto mbr_ptr{&SgEnumDeclaration::p_isScopedEnum};
14881 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14882 using bind = Desc<SgEnumDeclaration, bool SgEnumDeclaration::*, &SgEnumDeclaration::p_isScopedEnum>;
14883};
14884template <> struct describe_field_t<SgEnumDeclaration,int,&SgEnumDeclaration::p_name_qualification_length> {
14885 using parent = SgEnumDeclaration;
14886 using field_type = int;
14887 static constexpr size_t position{10};
14888 static constexpr char const * const name{"name_qualification_length"};
14889 static constexpr char const * const typestr{"int"};
14890 static constexpr bool traverse{false};
14891 static constexpr auto mbr_ptr{&SgEnumDeclaration::p_name_qualification_length};
14892 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14893 using bind = Desc<SgEnumDeclaration, int SgEnumDeclaration::*, &SgEnumDeclaration::p_name_qualification_length>;
14894};
14895template <> struct describe_field_t<SgEnumDeclaration,bool,&SgEnumDeclaration::p_type_elaboration_required> {
14896 using parent = SgEnumDeclaration;
14897 using field_type = bool;
14898 static constexpr size_t position{11};
14899 static constexpr char const * const name{"type_elaboration_required"};
14900 static constexpr char const * const typestr{"bool"};
14901 static constexpr bool traverse{false};
14902 static constexpr auto mbr_ptr{&SgEnumDeclaration::p_type_elaboration_required};
14903 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14904 using bind = Desc<SgEnumDeclaration, bool SgEnumDeclaration::*, &SgEnumDeclaration::p_type_elaboration_required>;
14905};
14906template <> struct describe_field_t<SgEnumDeclaration,bool,&SgEnumDeclaration::p_global_qualification_required> {
14907 using parent = SgEnumDeclaration;
14908 using field_type = bool;
14909 static constexpr size_t position{12};
14910 static constexpr char const * const name{"global_qualification_required"};
14911 static constexpr char const * const typestr{"bool"};
14912 static constexpr bool traverse{false};
14913 static constexpr auto mbr_ptr{&SgEnumDeclaration::p_global_qualification_required};
14914 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14915 using bind = Desc<SgEnumDeclaration, bool SgEnumDeclaration::*, &SgEnumDeclaration::p_global_qualification_required>;
14916};
14926template <> struct node_from_variant_t<404> { using type = SgEnumDeclaration; };
14927
14928// Class: EnumFieldSymbol
14929template <> struct describe_field_t<SgEnumFieldSymbol,SgInitializedName*,&SgEnumFieldSymbol::p_declaration> {
14930 using parent = SgEnumFieldSymbol;
14932 static constexpr size_t position{0};
14933 static constexpr char const * const name{"declaration"};
14934 static constexpr char const * const typestr{"SgInitializedName*"};
14935 static constexpr bool traverse{false};
14936 static constexpr auto mbr_ptr{&SgEnumFieldSymbol::p_declaration};
14937 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14938 using bind = Desc<SgEnumFieldSymbol, SgInitializedName* SgEnumFieldSymbol::*, &SgEnumFieldSymbol::p_declaration>;
14939};
14941 using node = SgEnumFieldSymbol;
14942 using base = SgSymbol;
14943 static constexpr char const * const name{"EnumFieldSymbol"};
14944 static constexpr unsigned long variant{405};
14945 static constexpr bool concrete{true};
14946 using subclasses_t = mp::List<>;
14948};
14949template <> struct node_from_variant_t<405> { using type = SgEnumFieldSymbol; };
14950
14951// Class: EnumSymbol
14952template <> struct describe_field_t<SgEnumSymbol,SgEnumDeclaration*,&SgEnumSymbol::p_declaration> {
14953 using parent = SgEnumSymbol;
14955 static constexpr size_t position{0};
14956 static constexpr char const * const name{"declaration"};
14957 static constexpr char const * const typestr{"SgEnumDeclaration*"};
14958 static constexpr bool traverse{true};
14959 static constexpr auto mbr_ptr{&SgEnumSymbol::p_declaration};
14960 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14961 using bind = Desc<SgEnumSymbol, SgEnumDeclaration* SgEnumSymbol::*, &SgEnumSymbol::p_declaration>;
14962};
14963template <> struct describe_node_t<SgEnumSymbol> {
14964 using node = SgEnumSymbol;
14965 using base = SgTypeSymbol;
14966 static constexpr char const * const name{"EnumSymbol"};
14967 static constexpr unsigned long variant{406};
14968 static constexpr bool concrete{true};
14969 using subclasses_t = mp::List<>;
14971};
14972template <> struct node_from_variant_t<406> { using type = SgEnumSymbol; };
14973
14974// Class: EnumType
14975template <> struct describe_node_t<SgEnumType> {
14976 using node = SgEnumType;
14977 using base = SgNamedType;
14978 static constexpr char const * const name{"EnumType"};
14979 static constexpr unsigned long variant{407};
14980 static constexpr bool concrete{true};
14981 using subclasses_t = mp::List<>;
14982 using fields_t = mp::List<>;
14983};
14984template <> struct node_from_variant_t<407> { using type = SgEnumType; };
14985
14986// Class: EnumVal
14987template <> struct describe_field_t<SgEnumVal,long long int,&SgEnumVal::p_value> {
14988 using parent = SgEnumVal;
14989 using field_type = long long int;
14990 static constexpr size_t position{0};
14991 static constexpr char const * const name{"value"};
14992 static constexpr char const * const typestr{"long long int"};
14993 static constexpr bool traverse{false};
14994 static constexpr auto mbr_ptr{&SgEnumVal::p_value};
14995 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
14996 using bind = Desc<SgEnumVal, long long int SgEnumVal::*, &SgEnumVal::p_value>;
14997};
14998template <> struct describe_field_t<SgEnumVal,SgEnumDeclaration*,&SgEnumVal::p_declaration> {
14999 using parent = SgEnumVal;
15001 static constexpr size_t position{1};
15002 static constexpr char const * const name{"declaration"};
15003 static constexpr char const * const typestr{"SgEnumDeclaration*"};
15004 static constexpr bool traverse{false};
15005 static constexpr auto mbr_ptr{&SgEnumVal::p_declaration};
15006 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15007 using bind = Desc<SgEnumVal, SgEnumDeclaration* SgEnumVal::*, &SgEnumVal::p_declaration>;
15008};
15009template <> struct describe_field_t<SgEnumVal,SgName,&SgEnumVal::p_name> {
15010 using parent = SgEnumVal;
15011 using field_type = SgName;
15012 static constexpr size_t position{2};
15013 static constexpr char const * const name{"name"};
15014 static constexpr char const * const typestr{"SgName"};
15015 static constexpr bool traverse{false};
15016 static constexpr auto mbr_ptr{&SgEnumVal::p_name};
15017 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15018 using bind = Desc<SgEnumVal, SgName SgEnumVal::*, &SgEnumVal::p_name>;
15019};
15020template <> struct describe_field_t<SgEnumVal,bool,&SgEnumVal::p_requiresNameQualification> {
15021 using parent = SgEnumVal;
15022 using field_type = bool;
15023 static constexpr size_t position{3};
15024 static constexpr char const * const name{"requiresNameQualification"};
15025 static constexpr char const * const typestr{"bool"};
15026 static constexpr bool traverse{false};
15027 static constexpr auto mbr_ptr{&SgEnumVal::p_requiresNameQualification};
15028 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15029 using bind = Desc<SgEnumVal, bool SgEnumVal::*, &SgEnumVal::p_requiresNameQualification>;
15030};
15031template <> struct describe_field_t<SgEnumVal,int,&SgEnumVal::p_name_qualification_length> {
15032 using parent = SgEnumVal;
15033 using field_type = int;
15034 static constexpr size_t position{4};
15035 static constexpr char const * const name{"name_qualification_length"};
15036 static constexpr char const * const typestr{"int"};
15037 static constexpr bool traverse{false};
15038 static constexpr auto mbr_ptr{&SgEnumVal::p_name_qualification_length};
15039 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15040 using bind = Desc<SgEnumVal, int SgEnumVal::*, &SgEnumVal::p_name_qualification_length>;
15041};
15042template <> struct describe_field_t<SgEnumVal,bool,&SgEnumVal::p_type_elaboration_required> {
15043 using parent = SgEnumVal;
15044 using field_type = bool;
15045 static constexpr size_t position{5};
15046 static constexpr char const * const name{"type_elaboration_required"};
15047 static constexpr char const * const typestr{"bool"};
15048 static constexpr bool traverse{false};
15049 static constexpr auto mbr_ptr{&SgEnumVal::p_type_elaboration_required};
15050 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15051 using bind = Desc<SgEnumVal, bool SgEnumVal::*, &SgEnumVal::p_type_elaboration_required>;
15052};
15053template <> struct describe_field_t<SgEnumVal,bool,&SgEnumVal::p_global_qualification_required> {
15054 using parent = SgEnumVal;
15055 using field_type = bool;
15056 static constexpr size_t position{6};
15057 static constexpr char const * const name{"global_qualification_required"};
15058 static constexpr char const * const typestr{"bool"};
15059 static constexpr bool traverse{false};
15060 static constexpr auto mbr_ptr{&SgEnumVal::p_global_qualification_required};
15061 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15062 using bind = Desc<SgEnumVal, bool SgEnumVal::*, &SgEnumVal::p_global_qualification_required>;
15063};
15073template <> struct node_from_variant_t<408> { using type = SgEnumVal; };
15074
15075// Class: EqualityOp
15076template <> struct describe_node_t<SgEqualityOp> {
15077 using node = SgEqualityOp;
15078 using base = SgBinaryOp;
15079 static constexpr char const * const name{"EqualityOp"};
15080 static constexpr unsigned long variant{409};
15081 static constexpr bool concrete{true};
15082 using subclasses_t = mp::List<>;
15083 using fields_t = mp::List<>;
15084};
15085template <> struct node_from_variant_t<409> { using type = SgEqualityOp; };
15086
15087// Class: EquivalenceStatement
15088template <> struct describe_field_t<SgEquivalenceStatement,SgExprListExp*,&SgEquivalenceStatement::p_equivalence_set_list> {
15090 using field_type = SgExprListExp*;
15091 static constexpr size_t position{0};
15092 static constexpr char const * const name{"equivalence_set_list"};
15093 static constexpr char const * const typestr{"SgExprListExp*"};
15094 static constexpr bool traverse{false};
15095 static constexpr auto mbr_ptr{&SgEquivalenceStatement::p_equivalence_set_list};
15096 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15097 using bind = Desc<SgEquivalenceStatement, SgExprListExp* SgEquivalenceStatement::*, &SgEquivalenceStatement::p_equivalence_set_list>;
15098};
15102 static constexpr char const * const name{"EquivalenceStatement"};
15103 static constexpr unsigned long variant{410};
15104 static constexpr bool concrete{true};
15105 using subclasses_t = mp::List<>;
15107};
15108template <> struct node_from_variant_t<410> { using type = SgEquivalenceStatement; };
15109
15110// Class: ErrorDirectiveStatement
15114 static constexpr char const * const name{"ErrorDirectiveStatement"};
15115 static constexpr unsigned long variant{411};
15116 static constexpr bool concrete{true};
15117 using subclasses_t = mp::List<>;
15118 using fields_t = mp::List<>;
15119};
15120template <> struct node_from_variant_t<411> { using type = SgErrorDirectiveStatement; };
15121
15122// Class: ExecStatement
15124 using parent = SgExecStatement;
15125 using field_type = SgExpression*;
15126 static constexpr size_t position{0};
15127 static constexpr char const * const name{"executable"};
15128 static constexpr char const * const typestr{"SgExpression*"};
15129 static constexpr bool traverse{true};
15130 static constexpr auto mbr_ptr{&SgExecStatement::p_executable};
15131 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15132 using bind = Desc<SgExecStatement, SgExpression* SgExecStatement::*, &SgExecStatement::p_executable>;
15133};
15135 using parent = SgExecStatement;
15136 using field_type = SgExpression*;
15137 static constexpr size_t position{1};
15138 static constexpr char const * const name{"globals"};
15139 static constexpr char const * const typestr{"SgExpression*"};
15140 static constexpr bool traverse{true};
15141 static constexpr auto mbr_ptr{&SgExecStatement::p_globals};
15142 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15143 using bind = Desc<SgExecStatement, SgExpression* SgExecStatement::*, &SgExecStatement::p_globals>;
15144};
15146 using parent = SgExecStatement;
15147 using field_type = SgExpression*;
15148 static constexpr size_t position{2};
15149 static constexpr char const * const name{"locals"};
15150 static constexpr char const * const typestr{"SgExpression*"};
15151 static constexpr bool traverse{true};
15152 static constexpr auto mbr_ptr{&SgExecStatement::p_locals};
15153 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15154 using bind = Desc<SgExecStatement, SgExpression* SgExecStatement::*, &SgExecStatement::p_locals>;
15155};
15157 using node = SgExecStatement;
15158 using base = SgStatement;
15159 static constexpr char const * const name{"ExecStatement"};
15160 static constexpr unsigned long variant{412};
15161 static constexpr bool concrete{true};
15162 using subclasses_t = mp::List<>;
15164};
15165template <> struct node_from_variant_t<412> { using type = SgExecStatement; };
15166
15167// Class: ExponentiationOp
15169 using node = SgExponentiationOp;
15170 using base = SgBinaryOp;
15171 static constexpr char const * const name{"ExponentiationOp"};
15172 static constexpr unsigned long variant{413};
15173 static constexpr bool concrete{true};
15174 using subclasses_t = mp::List<>;
15175 using fields_t = mp::List<>;
15176};
15177template <> struct node_from_variant_t<413> { using type = SgExponentiationOp; };
15178
15179// Class: ExponentiationAssignOp
15182 using base = SgCompoundAssignOp;
15183 static constexpr char const * const name{"ExponentiationAssignOp"};
15184 static constexpr unsigned long variant{414};
15185 static constexpr bool concrete{true};
15186 using subclasses_t = mp::List<>;
15187 using fields_t = mp::List<>;
15188};
15189template <> struct node_from_variant_t<414> { using type = SgExponentiationAssignOp; };
15190
15191// Class: ExprListExp
15192template <> struct describe_field_t<SgExprListExp,SgExpressionPtrList,&SgExprListExp::p_expressions> {
15193 using parent = SgExprListExp;
15194 using field_type = SgExpressionPtrList;
15195 static constexpr size_t position{0};
15196 static constexpr char const * const name{"expressions"};
15197 static constexpr char const * const typestr{"SgExpressionPtrList"};
15198 static constexpr bool traverse{true};
15199 static constexpr auto mbr_ptr{&SgExprListExp::p_expressions};
15200 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15201 using bind = Desc<SgExprListExp, SgExpressionPtrList SgExprListExp::*, &SgExprListExp::p_expressions>;
15202};
15203template <> struct describe_node_t<SgExprListExp> {
15204 using node = SgExprListExp;
15205 using base = SgExpression;
15206 static constexpr char const * const name{"ExprListExp"};
15207 static constexpr unsigned long variant{415};
15208 static constexpr bool concrete{true};
15211};
15212template <> struct node_from_variant_t<415> { using type = SgExprListExp; };
15213
15214// Class: ExprStatement
15215template <> struct describe_field_t<SgExprStatement,SgExpression*,&SgExprStatement::p_expression> {
15216 using parent = SgExprStatement;
15217 using field_type = SgExpression*;
15218 static constexpr size_t position{0};
15219 static constexpr char const * const name{"expression"};
15220 static constexpr char const * const typestr{"SgExpression*"};
15221 static constexpr bool traverse{true};
15222 static constexpr auto mbr_ptr{&SgExprStatement::p_expression};
15223 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15224 using bind = Desc<SgExprStatement, SgExpression* SgExprStatement::*, &SgExprStatement::p_expression>;
15225};
15227 using node = SgExprStatement;
15228 using base = SgStatement;
15229 static constexpr char const * const name{"ExprStatement"};
15230 static constexpr unsigned long variant{416};
15231 static constexpr bool concrete{true};
15232 using subclasses_t = mp::List<>;
15234};
15235template <> struct node_from_variant_t<416> { using type = SgExprStatement; };
15236
15237// Class: Expression
15239 using parent = SgExpression;
15240 using field_type = bool;
15241 static constexpr size_t position{0};
15242 static constexpr char const * const name{"need_paren"};
15243 static constexpr char const * const typestr{"bool"};
15244 static constexpr bool traverse{false};
15245 static constexpr auto mbr_ptr{&SgExpression::p_need_paren};
15246 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15247 using bind = Desc<SgExpression, bool SgExpression::*, &SgExpression::p_need_paren>;
15248};
15250 using parent = SgExpression;
15251 using field_type = bool;
15252 static constexpr size_t position{1};
15253 static constexpr char const * const name{"lvalue"};
15254 static constexpr char const * const typestr{"bool"};
15255 static constexpr bool traverse{false};
15256 static constexpr auto mbr_ptr{&SgExpression::p_lvalue};
15257 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15258 using bind = Desc<SgExpression, bool SgExpression::*, &SgExpression::p_lvalue>;
15259};
15260template <> struct describe_field_t<SgExpression,bool,&SgExpression::p_global_qualified_name> {
15261 using parent = SgExpression;
15262 using field_type = bool;
15263 static constexpr size_t position{2};
15264 static constexpr char const * const name{"global_qualified_name"};
15265 static constexpr char const * const typestr{"bool"};
15266 static constexpr bool traverse{false};
15267 static constexpr auto mbr_ptr{&SgExpression::p_global_qualified_name};
15268 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15269 using bind = Desc<SgExpression, bool SgExpression::*, &SgExpression::p_global_qualified_name>;
15270};
15271template <> struct describe_field_t<SgExpression,Sg_File_Info*,&SgExpression::p_operatorPosition> {
15272 using parent = SgExpression;
15273 using field_type = Sg_File_Info*;
15274 static constexpr size_t position{3};
15275 static constexpr char const * const name{"operatorPosition"};
15276 static constexpr char const * const typestr{"Sg_File_Info*"};
15277 static constexpr bool traverse{false};
15278 static constexpr auto mbr_ptr{&SgExpression::p_operatorPosition};
15279 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15280 using bind = Desc<SgExpression, Sg_File_Info* SgExpression::*, &SgExpression::p_operatorPosition>;
15281};
15282template <> struct describe_node_t<SgExpression> {
15283 using node = SgExpression;
15284 using base = SgLocatedNode;
15285 static constexpr char const * const name{"Expression"};
15286 static constexpr unsigned long variant{417};
15287 static constexpr bool concrete{false};
15290};
15291template <> struct node_from_variant_t<417> { using type = SgExpression; };
15292
15293// Class: ExpressionRoot
15295 using node = SgExpressionRoot;
15296 using base = SgUnaryOp;
15297 static constexpr char const * const name{"ExpressionRoot"};
15298 static constexpr unsigned long variant{418};
15299 static constexpr bool concrete{true};
15300 using subclasses_t = mp::List<>;
15301 using fields_t = mp::List<>;
15302};
15303template <> struct node_from_variant_t<418> { using type = SgExpressionRoot; };
15304
15305// Class: File
15306template <> struct describe_field_t<SgFile,Sg_File_Info*,&SgFile::p_startOfConstruct> {
15307 using parent = SgFile;
15308 using field_type = Sg_File_Info*;
15309 static constexpr size_t position{0};
15310 static constexpr char const * const name{"startOfConstruct"};
15311 static constexpr char const * const typestr{"Sg_File_Info*"};
15312 static constexpr bool traverse{false};
15313 static constexpr auto mbr_ptr{&SgFile::p_startOfConstruct};
15314 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15315 using bind = Desc<SgFile, Sg_File_Info* SgFile::*, &SgFile::p_startOfConstruct>;
15316};
15318 using parent = SgFile;
15319 using field_type = SgStringList;
15320 static constexpr size_t position{1};
15321 static constexpr char const * const name{"originalCommandLineArgumentList"};
15322 static constexpr char const * const typestr{"SgStringList"};
15323 static constexpr bool traverse{false};
15324 static constexpr auto mbr_ptr{&SgFile::p_originalCommandLineArgumentList};
15325 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15326 using bind = Desc<SgFile, SgStringList SgFile::*, &SgFile::p_originalCommandLineArgumentList>;
15327};
15328template <> struct describe_field_t<SgFile,int,&SgFile::p_verbose> {
15329 using parent = SgFile;
15330 using field_type = int;
15331 static constexpr size_t position{2};
15332 static constexpr char const * const name{"verbose"};
15333 static constexpr char const * const typestr{"int"};
15334 static constexpr bool traverse{false};
15335 static constexpr auto mbr_ptr{&SgFile::p_verbose};
15336 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15337 using bind = Desc<SgFile, int SgFile::*, &SgFile::p_verbose>;
15338};
15339template <> struct describe_field_t<SgFile,bool,&SgFile::p_output_warnings> {
15340 using parent = SgFile;
15341 using field_type = bool;
15342 static constexpr size_t position{3};
15343 static constexpr char const * const name{"output_warnings"};
15344 static constexpr char const * const typestr{"bool"};
15345 static constexpr bool traverse{false};
15346 static constexpr auto mbr_ptr{&SgFile::p_output_warnings};
15347 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15348 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_output_warnings>;
15349};
15350template <> struct describe_field_t<SgFile,bool,&SgFile::p_C_only> {
15351 using parent = SgFile;
15352 using field_type = bool;
15353 static constexpr size_t position{4};
15354 static constexpr char const * const name{"C_only"};
15355 static constexpr char const * const typestr{"bool"};
15356 static constexpr bool traverse{false};
15357 static constexpr auto mbr_ptr{&SgFile::p_C_only};
15358 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15359 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_C_only>;
15360};
15361template <> struct describe_field_t<SgFile,bool,&SgFile::p_Cxx_only> {
15362 using parent = SgFile;
15363 using field_type = bool;
15364 static constexpr size_t position{5};
15365 static constexpr char const * const name{"Cxx_only"};
15366 static constexpr char const * const typestr{"bool"};
15367 static constexpr bool traverse{false};
15368 static constexpr auto mbr_ptr{&SgFile::p_Cxx_only};
15369 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15370 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_Cxx_only>;
15371};
15372template <> struct describe_field_t<SgFile,bool,&SgFile::p_Fortran_only> {
15373 using parent = SgFile;
15374 using field_type = bool;
15375 static constexpr size_t position{6};
15376 static constexpr char const * const name{"Fortran_only"};
15377 static constexpr char const * const typestr{"bool"};
15378 static constexpr bool traverse{false};
15379 static constexpr auto mbr_ptr{&SgFile::p_Fortran_only};
15380 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15381 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_Fortran_only>;
15382};
15383template <> struct describe_field_t<SgFile,bool,&SgFile::p_CoArrayFortran_only> {
15384 using parent = SgFile;
15385 using field_type = bool;
15386 static constexpr size_t position{7};
15387 static constexpr char const * const name{"CoArrayFortran_only"};
15388 static constexpr char const * const typestr{"bool"};
15389 static constexpr bool traverse{false};
15390 static constexpr auto mbr_ptr{&SgFile::p_CoArrayFortran_only};
15391 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15392 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_CoArrayFortran_only>;
15393};
15394template <> struct describe_field_t<SgFile,int,&SgFile::p_upc_threads> {
15395 using parent = SgFile;
15396 using field_type = int;
15397 static constexpr size_t position{8};
15398 static constexpr char const * const name{"upc_threads"};
15399 static constexpr char const * const typestr{"int"};
15400 static constexpr bool traverse{false};
15401 static constexpr auto mbr_ptr{&SgFile::p_upc_threads};
15402 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15403 using bind = Desc<SgFile, int SgFile::*, &SgFile::p_upc_threads>;
15404};
15405template <> struct describe_field_t<SgFile,bool,&SgFile::p_Java_only> {
15406 using parent = SgFile;
15407 using field_type = bool;
15408 static constexpr size_t position{9};
15409 static constexpr char const * const name{"Java_only"};
15410 static constexpr char const * const typestr{"bool"};
15411 static constexpr bool traverse{false};
15412 static constexpr auto mbr_ptr{&SgFile::p_Java_only};
15413 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15414 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_Java_only>;
15415};
15416template <> struct describe_field_t<SgFile,bool,&SgFile::p_Jvm_only> {
15417 using parent = SgFile;
15418 using field_type = bool;
15419 static constexpr size_t position{10};
15420 static constexpr char const * const name{"Jvm_only"};
15421 static constexpr char const * const typestr{"bool"};
15422 static constexpr bool traverse{false};
15423 static constexpr auto mbr_ptr{&SgFile::p_Jvm_only};
15424 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15425 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_Jvm_only>;
15426};
15427template <> struct describe_field_t<SgFile,bool,&SgFile::p_Jovial_only> {
15428 using parent = SgFile;
15429 using field_type = bool;
15430 static constexpr size_t position{11};
15431 static constexpr char const * const name{"Jovial_only"};
15432 static constexpr char const * const typestr{"bool"};
15433 static constexpr bool traverse{false};
15434 static constexpr auto mbr_ptr{&SgFile::p_Jovial_only};
15435 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15436 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_Jovial_only>;
15437};
15438template <> struct describe_field_t<SgFile,bool,&SgFile::p_PHP_only> {
15439 using parent = SgFile;
15440 using field_type = bool;
15441 static constexpr size_t position{12};
15442 static constexpr char const * const name{"PHP_only"};
15443 static constexpr char const * const typestr{"bool"};
15444 static constexpr bool traverse{false};
15445 static constexpr auto mbr_ptr{&SgFile::p_PHP_only};
15446 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15447 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_PHP_only>;
15448};
15449template <> struct describe_field_t<SgFile,bool,&SgFile::p_Python_only> {
15450 using parent = SgFile;
15451 using field_type = bool;
15452 static constexpr size_t position{13};
15453 static constexpr char const * const name{"Python_only"};
15454 static constexpr char const * const typestr{"bool"};
15455 static constexpr bool traverse{false};
15456 static constexpr auto mbr_ptr{&SgFile::p_Python_only};
15457 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15458 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_Python_only>;
15459};
15460template <> struct describe_field_t<SgFile,bool,&SgFile::p_Cuda_only> {
15461 using parent = SgFile;
15462 using field_type = bool;
15463 static constexpr size_t position{14};
15464 static constexpr char const * const name{"Cuda_only"};
15465 static constexpr char const * const typestr{"bool"};
15466 static constexpr bool traverse{false};
15467 static constexpr auto mbr_ptr{&SgFile::p_Cuda_only};
15468 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15469 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_Cuda_only>;
15470};
15471template <> struct describe_field_t<SgFile,bool,&SgFile::p_OpenCL_only> {
15472 using parent = SgFile;
15473 using field_type = bool;
15474 static constexpr size_t position{15};
15475 static constexpr char const * const name{"OpenCL_only"};
15476 static constexpr char const * const typestr{"bool"};
15477 static constexpr bool traverse{false};
15478 static constexpr auto mbr_ptr{&SgFile::p_OpenCL_only};
15479 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15480 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_OpenCL_only>;
15481};
15482template <> struct describe_field_t<SgFile,bool,&SgFile::p_Csharp_only> {
15483 using parent = SgFile;
15484 using field_type = bool;
15485 static constexpr size_t position{16};
15486 static constexpr char const * const name{"Csharp_only"};
15487 static constexpr char const * const typestr{"bool"};
15488 static constexpr bool traverse{false};
15489 static constexpr auto mbr_ptr{&SgFile::p_Csharp_only};
15490 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15491 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_Csharp_only>;
15492};
15493template <> struct describe_field_t<SgFile,bool,&SgFile::p_Ada_only> {
15494 using parent = SgFile;
15495 using field_type = bool;
15496 static constexpr size_t position{17};
15497 static constexpr char const * const name{"Ada_only"};
15498 static constexpr char const * const typestr{"bool"};
15499 static constexpr bool traverse{false};
15500 static constexpr auto mbr_ptr{&SgFile::p_Ada_only};
15501 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15502 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_Ada_only>;
15503};
15504template <> struct describe_field_t<SgFile,bool,&SgFile::p_requires_C_preprocessor> {
15505 using parent = SgFile;
15506 using field_type = bool;
15507 static constexpr size_t position{18};
15508 static constexpr char const * const name{"requires_C_preprocessor"};
15509 static constexpr char const * const typestr{"bool"};
15510 static constexpr bool traverse{false};
15511 static constexpr auto mbr_ptr{&SgFile::p_requires_C_preprocessor};
15512 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15513 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_requires_C_preprocessor>;
15514};
15515template <> struct describe_field_t<SgFile,bool,&SgFile::p_binary_only> {
15516 using parent = SgFile;
15517 using field_type = bool;
15518 static constexpr size_t position{19};
15519 static constexpr char const * const name{"binary_only"};
15520 static constexpr char const * const typestr{"bool"};
15521 static constexpr bool traverse{false};
15522 static constexpr auto mbr_ptr{&SgFile::p_binary_only};
15523 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15524 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_binary_only>;
15525};
15526template <> struct describe_field_t<SgFile,SgFile::outputFormatOption_enum,&SgFile::p_inputFormat> {
15527 using parent = SgFile;
15529 static constexpr size_t position{20};
15530 static constexpr char const * const name{"inputFormat"};
15531 static constexpr char const * const typestr{"SgFile::outputFormatOption_enum"};
15532 static constexpr bool traverse{false};
15533 static constexpr auto mbr_ptr{&SgFile::p_inputFormat};
15534 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15535 using bind = Desc<SgFile, SgFile::outputFormatOption_enum SgFile::*, &SgFile::p_inputFormat>;
15536};
15537template <> struct describe_field_t<SgFile,SgFile::outputFormatOption_enum,&SgFile::p_outputFormat> {
15538 using parent = SgFile;
15540 static constexpr size_t position{21};
15541 static constexpr char const * const name{"outputFormat"};
15542 static constexpr char const * const typestr{"SgFile::outputFormatOption_enum"};
15543 static constexpr bool traverse{false};
15544 static constexpr auto mbr_ptr{&SgFile::p_outputFormat};
15545 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15546 using bind = Desc<SgFile, SgFile::outputFormatOption_enum SgFile::*, &SgFile::p_outputFormat>;
15547};
15548template <> struct describe_field_t<SgFile,SgFile::outputFormatOption_enum,&SgFile::p_backendCompileFormat> {
15549 using parent = SgFile;
15551 static constexpr size_t position{22};
15552 static constexpr char const * const name{"backendCompileFormat"};
15553 static constexpr char const * const typestr{"SgFile::outputFormatOption_enum"};
15554 static constexpr bool traverse{false};
15555 static constexpr auto mbr_ptr{&SgFile::p_backendCompileFormat};
15556 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15557 using bind = Desc<SgFile, SgFile::outputFormatOption_enum SgFile::*, &SgFile::p_backendCompileFormat>;
15558};
15559template <> struct describe_field_t<SgFile,bool,&SgFile::p_fortran_implicit_none> {
15560 using parent = SgFile;
15561 using field_type = bool;
15562 static constexpr size_t position{23};
15563 static constexpr char const * const name{"fortran_implicit_none"};
15564 static constexpr char const * const typestr{"bool"};
15565 static constexpr bool traverse{false};
15566 static constexpr auto mbr_ptr{&SgFile::p_fortran_implicit_none};
15567 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15568 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_fortran_implicit_none>;
15569};
15570template <> struct describe_field_t<SgFile,bool,&SgFile::p_openmp> {
15571 using parent = SgFile;
15572 using field_type = bool;
15573 static constexpr size_t position{24};
15574 static constexpr char const * const name{"openmp"};
15575 static constexpr char const * const typestr{"bool"};
15576 static constexpr bool traverse{false};
15577 static constexpr auto mbr_ptr{&SgFile::p_openmp};
15578 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15579 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_openmp>;
15580};
15581template <> struct describe_field_t<SgFile,bool,&SgFile::p_openmp_parse_only> {
15582 using parent = SgFile;
15583 using field_type = bool;
15584 static constexpr size_t position{25};
15585 static constexpr char const * const name{"openmp_parse_only"};
15586 static constexpr char const * const typestr{"bool"};
15587 static constexpr bool traverse{false};
15588 static constexpr auto mbr_ptr{&SgFile::p_openmp_parse_only};
15589 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15590 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_openmp_parse_only>;
15591};
15592template <> struct describe_field_t<SgFile,bool,&SgFile::p_openmp_ast_only> {
15593 using parent = SgFile;
15594 using field_type = bool;
15595 static constexpr size_t position{26};
15596 static constexpr char const * const name{"openmp_ast_only"};
15597 static constexpr char const * const typestr{"bool"};
15598 static constexpr bool traverse{false};
15599 static constexpr auto mbr_ptr{&SgFile::p_openmp_ast_only};
15600 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15601 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_openmp_ast_only>;
15602};
15603template <> struct describe_field_t<SgFile,bool,&SgFile::p_openmp_lowering> {
15604 using parent = SgFile;
15605 using field_type = bool;
15606 static constexpr size_t position{27};
15607 static constexpr char const * const name{"openmp_lowering"};
15608 static constexpr char const * const typestr{"bool"};
15609 static constexpr bool traverse{false};
15610 static constexpr auto mbr_ptr{&SgFile::p_openmp_lowering};
15611 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15612 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_openmp_lowering>;
15613};
15614template <> struct describe_field_t<SgFile,bool,&SgFile::p_openacc> {
15615 using parent = SgFile;
15616 using field_type = bool;
15617 static constexpr size_t position{28};
15618 static constexpr char const * const name{"openacc"};
15619 static constexpr char const * const typestr{"bool"};
15620 static constexpr bool traverse{false};
15621 static constexpr auto mbr_ptr{&SgFile::p_openacc};
15622 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15623 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_openacc>;
15624};
15625template <> struct describe_field_t<SgFile,bool,&SgFile::p_openacc_parse_only> {
15626 using parent = SgFile;
15627 using field_type = bool;
15628 static constexpr size_t position{29};
15629 static constexpr char const * const name{"openacc_parse_only"};
15630 static constexpr char const * const typestr{"bool"};
15631 static constexpr bool traverse{false};
15632 static constexpr auto mbr_ptr{&SgFile::p_openacc_parse_only};
15633 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15634 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_openacc_parse_only>;
15635};
15636template <> struct describe_field_t<SgFile,bool,&SgFile::p_openacc_ast_only> {
15637 using parent = SgFile;
15638 using field_type = bool;
15639 static constexpr size_t position{30};
15640 static constexpr char const * const name{"openacc_ast_only"};
15641 static constexpr char const * const typestr{"bool"};
15642 static constexpr bool traverse{false};
15643 static constexpr auto mbr_ptr{&SgFile::p_openacc_ast_only};
15644 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15645 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_openacc_ast_only>;
15646};
15647template <> struct describe_field_t<SgFile,bool,&SgFile::p_cray_pointer_support> {
15648 using parent = SgFile;
15649 using field_type = bool;
15650 static constexpr size_t position{31};
15651 static constexpr char const * const name{"cray_pointer_support"};
15652 static constexpr char const * const typestr{"bool"};
15653 static constexpr bool traverse{false};
15654 static constexpr auto mbr_ptr{&SgFile::p_cray_pointer_support};
15655 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15656 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_cray_pointer_support>;
15657};
15658template <> struct describe_field_t<SgFile,bool,&SgFile::p_failsafe> {
15659 using parent = SgFile;
15660 using field_type = bool;
15661 static constexpr size_t position{32};
15662 static constexpr char const * const name{"failsafe"};
15663 static constexpr char const * const typestr{"bool"};
15664 static constexpr bool traverse{false};
15665 static constexpr auto mbr_ptr{&SgFile::p_failsafe};
15666 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15667 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_failsafe>;
15668};
15669template <> struct describe_field_t<SgFile,bool,&SgFile::p_output_parser_actions> {
15670 using parent = SgFile;
15671 using field_type = bool;
15672 static constexpr size_t position{33};
15673 static constexpr char const * const name{"output_parser_actions"};
15674 static constexpr char const * const typestr{"bool"};
15675 static constexpr bool traverse{false};
15676 static constexpr auto mbr_ptr{&SgFile::p_output_parser_actions};
15677 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15678 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_output_parser_actions>;
15679};
15680template <> struct describe_field_t<SgFile,bool,&SgFile::p_exit_after_parser> {
15681 using parent = SgFile;
15682 using field_type = bool;
15683 static constexpr size_t position{34};
15684 static constexpr char const * const name{"exit_after_parser"};
15685 static constexpr char const * const typestr{"bool"};
15686 static constexpr bool traverse{false};
15687 static constexpr auto mbr_ptr{&SgFile::p_exit_after_parser};
15688 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15689 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_exit_after_parser>;
15690};
15691template <> struct describe_field_t<SgFile,bool,&SgFile::p_skip_syntax_check> {
15692 using parent = SgFile;
15693 using field_type = bool;
15694 static constexpr size_t position{35};
15695 static constexpr char const * const name{"skip_syntax_check"};
15696 static constexpr char const * const typestr{"bool"};
15697 static constexpr bool traverse{false};
15698 static constexpr auto mbr_ptr{&SgFile::p_skip_syntax_check};
15699 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15700 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_skip_syntax_check>;
15701};
15702template <> struct describe_field_t<SgFile,bool,&SgFile::p_skip_parser> {
15703 using parent = SgFile;
15704 using field_type = bool;
15705 static constexpr size_t position{36};
15706 static constexpr char const * const name{"skip_parser"};
15707 static constexpr char const * const typestr{"bool"};
15708 static constexpr bool traverse{false};
15709 static constexpr auto mbr_ptr{&SgFile::p_skip_parser};
15710 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15711 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_skip_parser>;
15712};
15713template <> struct describe_field_t<SgFile,bool,&SgFile::p_relax_syntax_check> {
15714 using parent = SgFile;
15715 using field_type = bool;
15716 static constexpr size_t position{37};
15717 static constexpr char const * const name{"relax_syntax_check"};
15718 static constexpr char const * const typestr{"bool"};
15719 static constexpr bool traverse{false};
15720 static constexpr auto mbr_ptr{&SgFile::p_relax_syntax_check};
15721 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15722 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_relax_syntax_check>;
15723};
15724template <> struct describe_field_t<SgFile,bool,&SgFile::p_skip_translation_from_edg_ast_to_rose_ast> {
15725 using parent = SgFile;
15726 using field_type = bool;
15727 static constexpr size_t position{38};
15728 static constexpr char const * const name{"skip_translation_from_edg_ast_to_rose_ast"};
15729 static constexpr char const * const typestr{"bool"};
15730 static constexpr bool traverse{false};
15731 static constexpr auto mbr_ptr{&SgFile::p_skip_translation_from_edg_ast_to_rose_ast};
15732 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15733 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_skip_translation_from_edg_ast_to_rose_ast>;
15734};
15735template <> struct describe_field_t<SgFile,bool,&SgFile::p_skip_transformation> {
15736 using parent = SgFile;
15737 using field_type = bool;
15738 static constexpr size_t position{39};
15739 static constexpr char const * const name{"skip_transformation"};
15740 static constexpr char const * const typestr{"bool"};
15741 static constexpr bool traverse{false};
15742 static constexpr auto mbr_ptr{&SgFile::p_skip_transformation};
15743 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15744 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_skip_transformation>;
15745};
15746template <> struct describe_field_t<SgFile,bool,&SgFile::p_skip_unparse> {
15747 using parent = SgFile;
15748 using field_type = bool;
15749 static constexpr size_t position{40};
15750 static constexpr char const * const name{"skip_unparse"};
15751 static constexpr char const * const typestr{"bool"};
15752 static constexpr bool traverse{false};
15753 static constexpr auto mbr_ptr{&SgFile::p_skip_unparse};
15754 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15755 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_skip_unparse>;
15756};
15757template <> struct describe_field_t<SgFile,bool,&SgFile::p_skipfinalCompileStep> {
15758 using parent = SgFile;
15759 using field_type = bool;
15760 static constexpr size_t position{41};
15761 static constexpr char const * const name{"skipfinalCompileStep"};
15762 static constexpr char const * const typestr{"bool"};
15763 static constexpr bool traverse{false};
15764 static constexpr auto mbr_ptr{&SgFile::p_skipfinalCompileStep};
15765 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15766 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_skipfinalCompileStep>;
15767};
15768template <> struct describe_field_t<SgFile,bool,&SgFile::p_unparse_includes> {
15769 using parent = SgFile;
15770 using field_type = bool;
15771 static constexpr size_t position{42};
15772 static constexpr char const * const name{"unparse_includes"};
15773 static constexpr char const * const typestr{"bool"};
15774 static constexpr bool traverse{false};
15775 static constexpr auto mbr_ptr{&SgFile::p_unparse_includes};
15776 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15777 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_unparse_includes>;
15778};
15779template <> struct describe_field_t<SgFile,bool,&SgFile::p_unparse_line_directives> {
15780 using parent = SgFile;
15781 using field_type = bool;
15782 static constexpr size_t position{43};
15783 static constexpr char const * const name{"unparse_line_directives"};
15784 static constexpr char const * const typestr{"bool"};
15785 static constexpr bool traverse{false};
15786 static constexpr auto mbr_ptr{&SgFile::p_unparse_line_directives};
15787 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15788 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_unparse_line_directives>;
15789};
15790template <> struct describe_field_t<SgFile,bool,&SgFile::p_unparse_function_calls_using_operator_syntax> {
15791 using parent = SgFile;
15792 using field_type = bool;
15793 static constexpr size_t position{44};
15794 static constexpr char const * const name{"unparse_function_calls_using_operator_syntax"};
15795 static constexpr char const * const typestr{"bool"};
15796 static constexpr bool traverse{false};
15797 static constexpr auto mbr_ptr{&SgFile::p_unparse_function_calls_using_operator_syntax};
15798 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15799 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_unparse_function_calls_using_operator_syntax>;
15800};
15801template <> struct describe_field_t<SgFile,bool,&SgFile::p_unparse_function_calls_using_operator_names> {
15802 using parent = SgFile;
15803 using field_type = bool;
15804 static constexpr size_t position{45};
15805 static constexpr char const * const name{"unparse_function_calls_using_operator_names"};
15806 static constexpr char const * const typestr{"bool"};
15807 static constexpr bool traverse{false};
15808 static constexpr auto mbr_ptr{&SgFile::p_unparse_function_calls_using_operator_names};
15809 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15810 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_unparse_function_calls_using_operator_names>;
15811};
15812template <> struct describe_field_t<SgFile,bool,&SgFile::p_unparse_instruction_addresses> {
15813 using parent = SgFile;
15814 using field_type = bool;
15815 static constexpr size_t position{46};
15816 static constexpr char const * const name{"unparse_instruction_addresses"};
15817 static constexpr char const * const typestr{"bool"};
15818 static constexpr bool traverse{false};
15819 static constexpr auto mbr_ptr{&SgFile::p_unparse_instruction_addresses};
15820 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15821 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_unparse_instruction_addresses>;
15822};
15823template <> struct describe_field_t<SgFile,bool,&SgFile::p_unparse_raw_memory_contents> {
15824 using parent = SgFile;
15825 using field_type = bool;
15826 static constexpr size_t position{47};
15827 static constexpr char const * const name{"unparse_raw_memory_contents"};
15828 static constexpr char const * const typestr{"bool"};
15829 static constexpr bool traverse{false};
15830 static constexpr auto mbr_ptr{&SgFile::p_unparse_raw_memory_contents};
15831 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15832 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_unparse_raw_memory_contents>;
15833};
15834template <> struct describe_field_t<SgFile,bool,&SgFile::p_unparse_binary_file_format> {
15835 using parent = SgFile;
15836 using field_type = bool;
15837 static constexpr size_t position{48};
15838 static constexpr char const * const name{"unparse_binary_file_format"};
15839 static constexpr char const * const typestr{"bool"};
15840 static constexpr bool traverse{false};
15841 static constexpr auto mbr_ptr{&SgFile::p_unparse_binary_file_format};
15842 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15843 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_unparse_binary_file_format>;
15844};
15845template <> struct describe_field_t<SgFile,SgFile::languageOption_enum,&SgFile::p_outputLanguage> {
15846 using parent = SgFile;
15848 static constexpr size_t position{49};
15849 static constexpr char const * const name{"outputLanguage"};
15850 static constexpr char const * const typestr{"SgFile::languageOption_enum"};
15851 static constexpr bool traverse{false};
15852 static constexpr auto mbr_ptr{&SgFile::p_outputLanguage};
15853 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15854 using bind = Desc<SgFile, SgFile::languageOption_enum SgFile::*, &SgFile::p_outputLanguage>;
15855};
15856template <> struct describe_field_t<SgFile,SgFile::languageOption_enum,&SgFile::p_inputLanguage> {
15857 using parent = SgFile;
15859 static constexpr size_t position{50};
15860 static constexpr char const * const name{"inputLanguage"};
15861 static constexpr char const * const typestr{"SgFile::languageOption_enum"};
15862 static constexpr bool traverse{false};
15863 static constexpr auto mbr_ptr{&SgFile::p_inputLanguage};
15864 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15865 using bind = Desc<SgFile, SgFile::languageOption_enum SgFile::*, &SgFile::p_inputLanguage>;
15866};
15867template <> struct describe_field_t<SgFile,std::string,&SgFile::p_sourceFileNameWithPath> {
15868 using parent = SgFile;
15869 using field_type = std::string;
15870 static constexpr size_t position{51};
15871 static constexpr char const * const name{"sourceFileNameWithPath"};
15872 static constexpr char const * const typestr{"std::string"};
15873 static constexpr bool traverse{false};
15874 static constexpr auto mbr_ptr{&SgFile::p_sourceFileNameWithPath};
15875 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15876 using bind = Desc<SgFile, std::string SgFile::*, &SgFile::p_sourceFileNameWithPath>;
15877};
15878template <> struct describe_field_t<SgFile,std::string,&SgFile::p_sourceFileNameWithoutPath> {
15879 using parent = SgFile;
15880 using field_type = std::string;
15881 static constexpr size_t position{52};
15882 static constexpr char const * const name{"sourceFileNameWithoutPath"};
15883 static constexpr char const * const typestr{"std::string"};
15884 static constexpr bool traverse{false};
15885 static constexpr auto mbr_ptr{&SgFile::p_sourceFileNameWithoutPath};
15886 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15887 using bind = Desc<SgFile, std::string SgFile::*, &SgFile::p_sourceFileNameWithoutPath>;
15888};
15889template <> struct describe_field_t<SgFile,std::string,&SgFile::p_unparse_output_filename> {
15890 using parent = SgFile;
15891 using field_type = std::string;
15892 static constexpr size_t position{53};
15893 static constexpr char const * const name{"unparse_output_filename"};
15894 static constexpr char const * const typestr{"std::string"};
15895 static constexpr bool traverse{false};
15896 static constexpr auto mbr_ptr{&SgFile::p_unparse_output_filename};
15897 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15898 using bind = Desc<SgFile, std::string SgFile::*, &SgFile::p_unparse_output_filename>;
15899};
15900template <> struct describe_field_t<SgFile,std::string,&SgFile::p_objectFileNameWithPath> {
15901 using parent = SgFile;
15902 using field_type = std::string;
15903 static constexpr size_t position{54};
15904 static constexpr char const * const name{"objectFileNameWithPath"};
15905 static constexpr char const * const typestr{"std::string"};
15906 static constexpr bool traverse{false};
15907 static constexpr auto mbr_ptr{&SgFile::p_objectFileNameWithPath};
15908 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15909 using bind = Desc<SgFile, std::string SgFile::*, &SgFile::p_objectFileNameWithPath>;
15910};
15911template <> struct describe_field_t<SgFile,std::string,&SgFile::p_objectFileNameWithoutPath> {
15912 using parent = SgFile;
15913 using field_type = std::string;
15914 static constexpr size_t position{55};
15915 static constexpr char const * const name{"objectFileNameWithoutPath"};
15916 static constexpr char const * const typestr{"std::string"};
15917 static constexpr bool traverse{false};
15918 static constexpr auto mbr_ptr{&SgFile::p_objectFileNameWithoutPath};
15919 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15920 using bind = Desc<SgFile, std::string SgFile::*, &SgFile::p_objectFileNameWithoutPath>;
15921};
15922template <> struct describe_field_t<SgFile,bool,&SgFile::p_useBackendOnly> {
15923 using parent = SgFile;
15924 using field_type = bool;
15925 static constexpr size_t position{56};
15926 static constexpr char const * const name{"useBackendOnly"};
15927 static constexpr char const * const typestr{"bool"};
15928 static constexpr bool traverse{false};
15929 static constexpr auto mbr_ptr{&SgFile::p_useBackendOnly};
15930 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15931 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_useBackendOnly>;
15932};
15933template <> struct describe_field_t<SgFile,bool,&SgFile::p_compileOnly> {
15934 using parent = SgFile;
15935 using field_type = bool;
15936 static constexpr size_t position{57};
15937 static constexpr char const * const name{"compileOnly"};
15938 static constexpr char const * const typestr{"bool"};
15939 static constexpr bool traverse{false};
15940 static constexpr auto mbr_ptr{&SgFile::p_compileOnly};
15941 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15942 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_compileOnly>;
15943};
15944template <> struct describe_field_t<SgFile,std::string,&SgFile::p_savedFrontendCommandLine> {
15945 using parent = SgFile;
15946 using field_type = std::string;
15947 static constexpr size_t position{58};
15948 static constexpr char const * const name{"savedFrontendCommandLine"};
15949 static constexpr char const * const typestr{"std::string"};
15950 static constexpr bool traverse{false};
15951 static constexpr auto mbr_ptr{&SgFile::p_savedFrontendCommandLine};
15952 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15953 using bind = Desc<SgFile, std::string SgFile::*, &SgFile::p_savedFrontendCommandLine>;
15954};
15956 using parent = SgFile;
15957 using field_type = bool;
15958 static constexpr size_t position{59};
15959 static constexpr char const * const name{"no_implicit_templates"};
15960 static constexpr char const * const typestr{"bool"};
15961 static constexpr bool traverse{false};
15962 static constexpr auto mbr_ptr{&SgFile::p_no_implicit_templates};
15963 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15964 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_no_implicit_templates>;
15965};
15967 using parent = SgFile;
15968 using field_type = bool;
15969 static constexpr size_t position{60};
15970 static constexpr char const * const name{"no_implicit_inline_templates"};
15971 static constexpr char const * const typestr{"bool"};
15972 static constexpr bool traverse{false};
15973 static constexpr auto mbr_ptr{&SgFile::p_no_implicit_inline_templates};
15974 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15975 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_no_implicit_inline_templates>;
15976};
15977template <> struct describe_field_t<SgFile,bool,&SgFile::p_skip_commentsAndDirectives> {
15978 using parent = SgFile;
15979 using field_type = bool;
15980 static constexpr size_t position{61};
15981 static constexpr char const * const name{"skip_commentsAndDirectives"};
15982 static constexpr char const * const typestr{"bool"};
15983 static constexpr bool traverse{false};
15984 static constexpr auto mbr_ptr{&SgFile::p_skip_commentsAndDirectives};
15985 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15986 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_skip_commentsAndDirectives>;
15987};
15988template <> struct describe_field_t<SgFile,bool,&SgFile::p_collectAllCommentsAndDirectives> {
15989 using parent = SgFile;
15990 using field_type = bool;
15991 static constexpr size_t position{62};
15992 static constexpr char const * const name{"collectAllCommentsAndDirectives"};
15993 static constexpr char const * const typestr{"bool"};
15994 static constexpr bool traverse{false};
15995 static constexpr auto mbr_ptr{&SgFile::p_collectAllCommentsAndDirectives};
15996 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
15997 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_collectAllCommentsAndDirectives>;
15998};
15999template <> struct describe_field_t<SgFile,bool,&SgFile::p_translateCommentsAndDirectivesIntoAST> {
16000 using parent = SgFile;
16001 using field_type = bool;
16002 static constexpr size_t position{63};
16003 static constexpr char const * const name{"translateCommentsAndDirectivesIntoAST"};
16004 static constexpr char const * const typestr{"bool"};
16005 static constexpr bool traverse{false};
16006 static constexpr auto mbr_ptr{&SgFile::p_translateCommentsAndDirectivesIntoAST};
16007 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16008 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_translateCommentsAndDirectivesIntoAST>;
16009};
16010template <> struct describe_field_t<SgFile,bool,&SgFile::p_unparseHeaderFiles> {
16011 using parent = SgFile;
16012 using field_type = bool;
16013 static constexpr size_t position{64};
16014 static constexpr char const * const name{"unparseHeaderFiles"};
16015 static constexpr char const * const typestr{"bool"};
16016 static constexpr bool traverse{false};
16017 static constexpr auto mbr_ptr{&SgFile::p_unparseHeaderFiles};
16018 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16019 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_unparseHeaderFiles>;
16020};
16022 using parent = SgFile;
16024 static constexpr size_t position{65};
16025 static constexpr char const * const name{"preprocessorDirectivesAndCommentsList"};
16026 static constexpr char const * const typestr{"ROSEAttributesListContainerPtr"};
16027 static constexpr bool traverse{false};
16028 static constexpr auto mbr_ptr{&SgFile::p_preprocessorDirectivesAndCommentsList};
16029 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16030 using bind = Desc<SgFile, ROSEAttributesListContainerPtr SgFile::*, &SgFile::p_preprocessorDirectivesAndCommentsList>;
16031};
16032template <> struct describe_field_t<SgFile,AstAttributeMechanism*,&SgFile::p_attributeMechanism> {
16033 using parent = SgFile;
16035 static constexpr size_t position{66};
16036 static constexpr char const * const name{"attributeMechanism"};
16037 static constexpr char const * const typestr{"AstAttributeMechanism*"};
16038 static constexpr bool traverse{false};
16039 static constexpr auto mbr_ptr{&SgFile::p_attributeMechanism};
16040 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16041 using bind = Desc<SgFile, AstAttributeMechanism* SgFile::*, &SgFile::p_attributeMechanism>;
16042};
16043template <> struct describe_field_t<SgFile,bool,&SgFile::p_KCC_frontend> {
16044 using parent = SgFile;
16045 using field_type = bool;
16046 static constexpr size_t position{67};
16047 static constexpr char const * const name{"KCC_frontend"};
16048 static constexpr char const * const typestr{"bool"};
16049 static constexpr bool traverse{false};
16050 static constexpr auto mbr_ptr{&SgFile::p_KCC_frontend};
16051 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16052 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_KCC_frontend>;
16053};
16054template <> struct describe_field_t<SgFile,bool,&SgFile::p_new_frontend> {
16055 using parent = SgFile;
16056 using field_type = bool;
16057 static constexpr size_t position{68};
16058 static constexpr char const * const name{"new_frontend"};
16059 static constexpr char const * const typestr{"bool"};
16060 static constexpr bool traverse{false};
16061 static constexpr auto mbr_ptr{&SgFile::p_new_frontend};
16062 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16063 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_new_frontend>;
16064};
16065template <> struct describe_field_t<SgFile,bool,&SgFile::p_disable_edg_backend> {
16066 using parent = SgFile;
16067 using field_type = bool;
16068 static constexpr size_t position{69};
16069 static constexpr char const * const name{"disable_edg_backend"};
16070 static constexpr char const * const typestr{"bool"};
16071 static constexpr bool traverse{false};
16072 static constexpr auto mbr_ptr{&SgFile::p_disable_edg_backend};
16073 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16074 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_disable_edg_backend>;
16075};
16076template <> struct describe_field_t<SgFile,bool,&SgFile::p_disable_sage_backend> {
16077 using parent = SgFile;
16078 using field_type = bool;
16079 static constexpr size_t position{70};
16080 static constexpr char const * const name{"disable_sage_backend"};
16081 static constexpr char const * const typestr{"bool"};
16082 static constexpr bool traverse{false};
16083 static constexpr auto mbr_ptr{&SgFile::p_disable_sage_backend};
16084 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16085 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_disable_sage_backend>;
16086};
16087template <> struct describe_field_t<SgFile,int,&SgFile::p_testingLevel> {
16088 using parent = SgFile;
16089 using field_type = int;
16090 static constexpr size_t position{71};
16091 static constexpr char const * const name{"testingLevel"};
16092 static constexpr char const * const typestr{"int"};
16093 static constexpr bool traverse{false};
16094 static constexpr auto mbr_ptr{&SgFile::p_testingLevel};
16095 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16096 using bind = Desc<SgFile, int SgFile::*, &SgFile::p_testingLevel>;
16097};
16098template <> struct describe_field_t<SgFile,bool,&SgFile::p_preinit_il> {
16099 using parent = SgFile;
16100 using field_type = bool;
16101 static constexpr size_t position{72};
16102 static constexpr char const * const name{"preinit_il"};
16103 static constexpr char const * const typestr{"bool"};
16104 static constexpr bool traverse{false};
16105 static constexpr auto mbr_ptr{&SgFile::p_preinit_il};
16106 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16107 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_preinit_il>;
16108};
16109template <> struct describe_field_t<SgFile,bool,&SgFile::p_enable_cp_backend> {
16110 using parent = SgFile;
16111 using field_type = bool;
16112 static constexpr size_t position{73};
16113 static constexpr char const * const name{"enable_cp_backend"};
16114 static constexpr char const * const typestr{"bool"};
16115 static constexpr bool traverse{false};
16116 static constexpr auto mbr_ptr{&SgFile::p_enable_cp_backend};
16117 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16118 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_enable_cp_backend>;
16119};
16120template <> struct describe_field_t<SgFile,bool,&SgFile::p_markGeneratedFiles> {
16121 using parent = SgFile;
16122 using field_type = bool;
16123 static constexpr size_t position{74};
16124 static constexpr char const * const name{"markGeneratedFiles"};
16125 static constexpr char const * const typestr{"bool"};
16126 static constexpr bool traverse{false};
16127 static constexpr auto mbr_ptr{&SgFile::p_markGeneratedFiles};
16128 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16129 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_markGeneratedFiles>;
16130};
16131template <> struct describe_field_t<SgFile,bool,&SgFile::p_negative_test> {
16132 using parent = SgFile;
16133 using field_type = bool;
16134 static constexpr size_t position{75};
16135 static constexpr char const * const name{"negative_test"};
16136 static constexpr char const * const typestr{"bool"};
16137 static constexpr bool traverse{false};
16138 static constexpr auto mbr_ptr{&SgFile::p_negative_test};
16139 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16140 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_negative_test>;
16141};
16142template <> struct describe_field_t<SgFile,bool,&SgFile::p_strict_language_handling> {
16143 using parent = SgFile;
16144 using field_type = bool;
16145 static constexpr size_t position{76};
16146 static constexpr char const * const name{"strict_language_handling"};
16147 static constexpr char const * const typestr{"bool"};
16148 static constexpr bool traverse{false};
16149 static constexpr auto mbr_ptr{&SgFile::p_strict_language_handling};
16150 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16151 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_strict_language_handling>;
16152};
16153template <> struct describe_field_t<SgFile,bool,&SgFile::p_wave> {
16154 using parent = SgFile;
16155 using field_type = bool;
16156 static constexpr size_t position{77};
16157 static constexpr char const * const name{"wave"};
16158 static constexpr char const * const typestr{"bool"};
16159 static constexpr bool traverse{false};
16160 static constexpr auto mbr_ptr{&SgFile::p_wave};
16161 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16162 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_wave>;
16163};
16164template <> struct describe_field_t<SgFile,int,&SgFile::p_embedColorCodesInGeneratedCode> {
16165 using parent = SgFile;
16166 using field_type = int;
16167 static constexpr size_t position{78};
16168 static constexpr char const * const name{"embedColorCodesInGeneratedCode"};
16169 static constexpr char const * const typestr{"int"};
16170 static constexpr bool traverse{false};
16171 static constexpr auto mbr_ptr{&SgFile::p_embedColorCodesInGeneratedCode};
16172 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16173 using bind = Desc<SgFile, int SgFile::*, &SgFile::p_embedColorCodesInGeneratedCode>;
16174};
16175template <> struct describe_field_t<SgFile,int,&SgFile::p_generateSourcePositionCodes> {
16176 using parent = SgFile;
16177 using field_type = int;
16178 static constexpr size_t position{79};
16179 static constexpr char const * const name{"generateSourcePositionCodes"};
16180 static constexpr char const * const typestr{"int"};
16181 static constexpr bool traverse{false};
16182 static constexpr auto mbr_ptr{&SgFile::p_generateSourcePositionCodes};
16183 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16184 using bind = Desc<SgFile, int SgFile::*, &SgFile::p_generateSourcePositionCodes>;
16185};
16186template <> struct describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesCppFileExtension> {
16187 using parent = SgFile;
16188 using field_type = bool;
16189 static constexpr size_t position{80};
16190 static constexpr char const * const name{"sourceFileUsesCppFileExtension"};
16191 static constexpr char const * const typestr{"bool"};
16192 static constexpr bool traverse{false};
16193 static constexpr auto mbr_ptr{&SgFile::p_sourceFileUsesCppFileExtension};
16194 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16195 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_sourceFileUsesCppFileExtension>;
16196};
16197template <> struct describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesFortranFileExtension> {
16198 using parent = SgFile;
16199 using field_type = bool;
16200 static constexpr size_t position{81};
16201 static constexpr char const * const name{"sourceFileUsesFortranFileExtension"};
16202 static constexpr char const * const typestr{"bool"};
16203 static constexpr bool traverse{false};
16204 static constexpr auto mbr_ptr{&SgFile::p_sourceFileUsesFortranFileExtension};
16205 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16206 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_sourceFileUsesFortranFileExtension>;
16207};
16208template <> struct describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesFortran77FileExtension> {
16209 using parent = SgFile;
16210 using field_type = bool;
16211 static constexpr size_t position{82};
16212 static constexpr char const * const name{"sourceFileUsesFortran77FileExtension"};
16213 static constexpr char const * const typestr{"bool"};
16214 static constexpr bool traverse{false};
16215 static constexpr auto mbr_ptr{&SgFile::p_sourceFileUsesFortran77FileExtension};
16216 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16217 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_sourceFileUsesFortran77FileExtension>;
16218};
16219template <> struct describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesFortran90FileExtension> {
16220 using parent = SgFile;
16221 using field_type = bool;
16222 static constexpr size_t position{83};
16223 static constexpr char const * const name{"sourceFileUsesFortran90FileExtension"};
16224 static constexpr char const * const typestr{"bool"};
16225 static constexpr bool traverse{false};
16226 static constexpr auto mbr_ptr{&SgFile::p_sourceFileUsesFortran90FileExtension};
16227 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16228 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_sourceFileUsesFortran90FileExtension>;
16229};
16230template <> struct describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesFortran95FileExtension> {
16231 using parent = SgFile;
16232 using field_type = bool;
16233 static constexpr size_t position{84};
16234 static constexpr char const * const name{"sourceFileUsesFortran95FileExtension"};
16235 static constexpr char const * const typestr{"bool"};
16236 static constexpr bool traverse{false};
16237 static constexpr auto mbr_ptr{&SgFile::p_sourceFileUsesFortran95FileExtension};
16238 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16239 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_sourceFileUsesFortran95FileExtension>;
16240};
16241template <> struct describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesFortran2003FileExtension> {
16242 using parent = SgFile;
16243 using field_type = bool;
16244 static constexpr size_t position{85};
16245 static constexpr char const * const name{"sourceFileUsesFortran2003FileExtension"};
16246 static constexpr char const * const typestr{"bool"};
16247 static constexpr bool traverse{false};
16248 static constexpr auto mbr_ptr{&SgFile::p_sourceFileUsesFortran2003FileExtension};
16249 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16250 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_sourceFileUsesFortran2003FileExtension>;
16251};
16252template <> struct describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesFortran2008FileExtension> {
16253 using parent = SgFile;
16254 using field_type = bool;
16255 static constexpr size_t position{86};
16256 static constexpr char const * const name{"sourceFileUsesFortran2008FileExtension"};
16257 static constexpr char const * const typestr{"bool"};
16258 static constexpr bool traverse{false};
16259 static constexpr auto mbr_ptr{&SgFile::p_sourceFileUsesFortran2008FileExtension};
16260 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16261 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_sourceFileUsesFortran2008FileExtension>;
16262};
16263template <> struct describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesCoArrayFortranFileExtension> {
16264 using parent = SgFile;
16265 using field_type = bool;
16266 static constexpr size_t position{87};
16267 static constexpr char const * const name{"sourceFileUsesCoArrayFortranFileExtension"};
16268 static constexpr char const * const typestr{"bool"};
16269 static constexpr bool traverse{false};
16270 static constexpr auto mbr_ptr{&SgFile::p_sourceFileUsesCoArrayFortranFileExtension};
16271 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16272 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_sourceFileUsesCoArrayFortranFileExtension>;
16273};
16274template <> struct describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesPHPFileExtension> {
16275 using parent = SgFile;
16276 using field_type = bool;
16277 static constexpr size_t position{88};
16278 static constexpr char const * const name{"sourceFileUsesPHPFileExtension"};
16279 static constexpr char const * const typestr{"bool"};
16280 static constexpr bool traverse{false};
16281 static constexpr auto mbr_ptr{&SgFile::p_sourceFileUsesPHPFileExtension};
16282 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16283 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_sourceFileUsesPHPFileExtension>;
16284};
16285template <> struct describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesPythonFileExtension> {
16286 using parent = SgFile;
16287 using field_type = bool;
16288 static constexpr size_t position{89};
16289 static constexpr char const * const name{"sourceFileUsesPythonFileExtension"};
16290 static constexpr char const * const typestr{"bool"};
16291 static constexpr bool traverse{false};
16292 static constexpr auto mbr_ptr{&SgFile::p_sourceFileUsesPythonFileExtension};
16293 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16294 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_sourceFileUsesPythonFileExtension>;
16295};
16296template <> struct describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesJavaFileExtension> {
16297 using parent = SgFile;
16298 using field_type = bool;
16299 static constexpr size_t position{90};
16300 static constexpr char const * const name{"sourceFileUsesJavaFileExtension"};
16301 static constexpr char const * const typestr{"bool"};
16302 static constexpr bool traverse{false};
16303 static constexpr auto mbr_ptr{&SgFile::p_sourceFileUsesJavaFileExtension};
16304 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16305 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_sourceFileUsesJavaFileExtension>;
16306};
16307template <> struct describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesJvmFileExtension> {
16308 using parent = SgFile;
16309 using field_type = bool;
16310 static constexpr size_t position{91};
16311 static constexpr char const * const name{"sourceFileUsesJvmFileExtension"};
16312 static constexpr char const * const typestr{"bool"};
16313 static constexpr bool traverse{false};
16314 static constexpr auto mbr_ptr{&SgFile::p_sourceFileUsesJvmFileExtension};
16315 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16316 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_sourceFileUsesJvmFileExtension>;
16317};
16318template <> struct describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesBinaryFileExtension> {
16319 using parent = SgFile;
16320 using field_type = bool;
16321 static constexpr size_t position{92};
16322 static constexpr char const * const name{"sourceFileUsesBinaryFileExtension"};
16323 static constexpr char const * const typestr{"bool"};
16324 static constexpr bool traverse{false};
16325 static constexpr auto mbr_ptr{&SgFile::p_sourceFileUsesBinaryFileExtension};
16326 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16327 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_sourceFileUsesBinaryFileExtension>;
16328};
16329template <> struct describe_field_t<SgFile,bool,&SgFile::p_sourceFileTypeIsUnknown> {
16330 using parent = SgFile;
16331 using field_type = bool;
16332 static constexpr size_t position{93};
16333 static constexpr char const * const name{"sourceFileTypeIsUnknown"};
16334 static constexpr char const * const typestr{"bool"};
16335 static constexpr bool traverse{false};
16336 static constexpr auto mbr_ptr{&SgFile::p_sourceFileTypeIsUnknown};
16337 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16338 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_sourceFileTypeIsUnknown>;
16339};
16340template <> struct describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesCsharpFileExtension> {
16341 using parent = SgFile;
16342 using field_type = bool;
16343 static constexpr size_t position{94};
16344 static constexpr char const * const name{"sourceFileUsesCsharpFileExtension"};
16345 static constexpr char const * const typestr{"bool"};
16346 static constexpr bool traverse{false};
16347 static constexpr auto mbr_ptr{&SgFile::p_sourceFileUsesCsharpFileExtension};
16348 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16349 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_sourceFileUsesCsharpFileExtension>;
16350};
16351template <> struct describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesAdaFileExtension> {
16352 using parent = SgFile;
16353 using field_type = bool;
16354 static constexpr size_t position{95};
16355 static constexpr char const * const name{"sourceFileUsesAdaFileExtension"};
16356 static constexpr char const * const typestr{"bool"};
16357 static constexpr bool traverse{false};
16358 static constexpr auto mbr_ptr{&SgFile::p_sourceFileUsesAdaFileExtension};
16359 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16360 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_sourceFileUsesAdaFileExtension>;
16361};
16362template <> struct describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesJovialFileExtension> {
16363 using parent = SgFile;
16364 using field_type = bool;
16365 static constexpr size_t position{96};
16366 static constexpr char const * const name{"sourceFileUsesJovialFileExtension"};
16367 static constexpr char const * const typestr{"bool"};
16368 static constexpr bool traverse{false};
16369 static constexpr auto mbr_ptr{&SgFile::p_sourceFileUsesJovialFileExtension};
16370 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16371 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_sourceFileUsesJovialFileExtension>;
16372};
16373template <> struct describe_field_t<SgFile,int,&SgFile::p_detect_dangling_pointers> {
16374 using parent = SgFile;
16375 using field_type = int;
16376 static constexpr size_t position{97};
16377 static constexpr char const * const name{"detect_dangling_pointers"};
16378 static constexpr char const * const typestr{"int"};
16379 static constexpr bool traverse{false};
16380 static constexpr auto mbr_ptr{&SgFile::p_detect_dangling_pointers};
16381 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16382 using bind = Desc<SgFile, int SgFile::*, &SgFile::p_detect_dangling_pointers>;
16383};
16384template <> struct describe_field_t<SgFile,bool,&SgFile::p_experimental_flang_frontend> {
16385 using parent = SgFile;
16386 using field_type = bool;
16387 static constexpr size_t position{98};
16388 static constexpr char const * const name{"experimental_flang_frontend"};
16389 static constexpr char const * const typestr{"bool"};
16390 static constexpr bool traverse{false};
16391 static constexpr auto mbr_ptr{&SgFile::p_experimental_flang_frontend};
16392 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16393 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_experimental_flang_frontend>;
16394};
16395template <> struct describe_field_t<SgFile,bool,&SgFile::p_read_executable_file_format_only> {
16396 using parent = SgFile;
16397 using field_type = bool;
16398 static constexpr size_t position{99};
16399 static constexpr char const * const name{"read_executable_file_format_only"};
16400 static constexpr char const * const typestr{"bool"};
16401 static constexpr bool traverse{false};
16402 static constexpr auto mbr_ptr{&SgFile::p_read_executable_file_format_only};
16403 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16404 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_read_executable_file_format_only>;
16405};
16406template <> struct describe_field_t<SgFile,bool,&SgFile::p_visualize_executable_file_format_skip_symbols> {
16407 using parent = SgFile;
16408 using field_type = bool;
16409 static constexpr size_t position{100};
16410 static constexpr char const * const name{"visualize_executable_file_format_skip_symbols"};
16411 static constexpr char const * const typestr{"bool"};
16412 static constexpr bool traverse{false};
16413 static constexpr auto mbr_ptr{&SgFile::p_visualize_executable_file_format_skip_symbols};
16414 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16415 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_visualize_executable_file_format_skip_symbols>;
16416};
16417template <> struct describe_field_t<SgFile,bool,&SgFile::p_visualize_dwarf_only> {
16418 using parent = SgFile;
16419 using field_type = bool;
16420 static constexpr size_t position{101};
16421 static constexpr char const * const name{"visualize_dwarf_only"};
16422 static constexpr char const * const typestr{"bool"};
16423 static constexpr bool traverse{false};
16424 static constexpr auto mbr_ptr{&SgFile::p_visualize_dwarf_only};
16425 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16426 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_visualize_dwarf_only>;
16427};
16428template <> struct describe_field_t<SgFile,bool,&SgFile::p_read_instructions_only> {
16429 using parent = SgFile;
16430 using field_type = bool;
16431 static constexpr size_t position{102};
16432 static constexpr char const * const name{"read_instructions_only"};
16433 static constexpr char const * const typestr{"bool"};
16434 static constexpr bool traverse{false};
16435 static constexpr auto mbr_ptr{&SgFile::p_read_instructions_only};
16436 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16437 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_read_instructions_only>;
16438};
16439template <> struct describe_field_t<SgFile,SgStringList,&SgFile::p_libraryArchiveObjectFileNameList> {
16440 using parent = SgFile;
16441 using field_type = SgStringList;
16442 static constexpr size_t position{103};
16443 static constexpr char const * const name{"libraryArchiveObjectFileNameList"};
16444 static constexpr char const * const typestr{"SgStringList"};
16445 static constexpr bool traverse{false};
16446 static constexpr auto mbr_ptr{&SgFile::p_libraryArchiveObjectFileNameList};
16447 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16448 using bind = Desc<SgFile, SgStringList SgFile::*, &SgFile::p_libraryArchiveObjectFileNameList>;
16449};
16450template <> struct describe_field_t<SgFile,bool,&SgFile::p_isLibraryArchive> {
16451 using parent = SgFile;
16452 using field_type = bool;
16453 static constexpr size_t position{104};
16454 static constexpr char const * const name{"isLibraryArchive"};
16455 static constexpr char const * const typestr{"bool"};
16456 static constexpr bool traverse{false};
16457 static constexpr auto mbr_ptr{&SgFile::p_isLibraryArchive};
16458 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16459 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_isLibraryArchive>;
16460};
16461template <> struct describe_field_t<SgFile,bool,&SgFile::p_isObjectFile> {
16462 using parent = SgFile;
16463 using field_type = bool;
16464 static constexpr size_t position{105};
16465 static constexpr char const * const name{"isObjectFile"};
16466 static constexpr char const * const typestr{"bool"};
16467 static constexpr bool traverse{false};
16468 static constexpr auto mbr_ptr{&SgFile::p_isObjectFile};
16469 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16470 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_isObjectFile>;
16471};
16472template <> struct describe_field_t<SgFile,bool,&SgFile::p_unparse_tokens> {
16473 using parent = SgFile;
16474 using field_type = bool;
16475 static constexpr size_t position{106};
16476 static constexpr char const * const name{"unparse_tokens"};
16477 static constexpr char const * const typestr{"bool"};
16478 static constexpr bool traverse{false};
16479 static constexpr auto mbr_ptr{&SgFile::p_unparse_tokens};
16480 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16481 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_unparse_tokens>;
16482};
16483template <> struct describe_field_t<SgFile,int,&SgFile::p_unparse_tokens_testing> {
16484 using parent = SgFile;
16485 using field_type = int;
16486 static constexpr size_t position{107};
16487 static constexpr char const * const name{"unparse_tokens_testing"};
16488 static constexpr char const * const typestr{"int"};
16489 static constexpr bool traverse{false};
16490 static constexpr auto mbr_ptr{&SgFile::p_unparse_tokens_testing};
16491 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16492 using bind = Desc<SgFile, int SgFile::*, &SgFile::p_unparse_tokens_testing>;
16493};
16494template <> struct describe_field_t<SgFile,bool,&SgFile::p_unparse_using_leading_and_trailing_token_mappings> {
16495 using parent = SgFile;
16496 using field_type = bool;
16497 static constexpr size_t position{108};
16498 static constexpr char const * const name{"unparse_using_leading_and_trailing_token_mappings"};
16499 static constexpr char const * const typestr{"bool"};
16500 static constexpr bool traverse{false};
16501 static constexpr auto mbr_ptr{&SgFile::p_unparse_using_leading_and_trailing_token_mappings};
16502 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16503 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_unparse_using_leading_and_trailing_token_mappings>;
16504};
16505template <> struct describe_field_t<SgFile,bool,&SgFile::p_unparse_template_ast> {
16506 using parent = SgFile;
16507 using field_type = bool;
16508 static constexpr size_t position{109};
16509 static constexpr char const * const name{"unparse_template_ast"};
16510 static constexpr char const * const typestr{"bool"};
16511 static constexpr bool traverse{false};
16512 static constexpr auto mbr_ptr{&SgFile::p_unparse_template_ast};
16513 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16514 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_unparse_template_ast>;
16515};
16516template <> struct describe_field_t<SgFile,bool,&SgFile::p_skipAstConsistancyTests> {
16517 using parent = SgFile;
16518 using field_type = bool;
16519 static constexpr size_t position{110};
16520 static constexpr char const * const name{"skipAstConsistancyTests"};
16521 static constexpr char const * const typestr{"bool"};
16522 static constexpr bool traverse{false};
16523 static constexpr auto mbr_ptr{&SgFile::p_skipAstConsistancyTests};
16524 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16525 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_skipAstConsistancyTests>;
16526};
16527template <> struct describe_field_t<SgFile,bool,&SgFile::p_multifile_support> {
16528 using parent = SgFile;
16529 using field_type = bool;
16530 static constexpr size_t position{111};
16531 static constexpr char const * const name{"multifile_support"};
16532 static constexpr char const * const typestr{"bool"};
16533 static constexpr bool traverse{false};
16534 static constexpr auto mbr_ptr{&SgFile::p_multifile_support};
16535 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16536 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_multifile_support>;
16537};
16538template <> struct describe_field_t<SgFile,bool,&SgFile::p_optimization> {
16539 using parent = SgFile;
16540 using field_type = bool;
16541 static constexpr size_t position{112};
16542 static constexpr char const * const name{"optimization"};
16543 static constexpr char const * const typestr{"bool"};
16544 static constexpr bool traverse{false};
16545 static constexpr auto mbr_ptr{&SgFile::p_optimization};
16546 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16547 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_optimization>;
16548};
16549template <> struct describe_field_t<SgFile,bool,&SgFile::p_use_token_stream_to_improve_source_position_info> {
16550 using parent = SgFile;
16551 using field_type = bool;
16552 static constexpr size_t position{113};
16553 static constexpr char const * const name{"use_token_stream_to_improve_source_position_info"};
16554 static constexpr char const * const typestr{"bool"};
16555 static constexpr bool traverse{false};
16556 static constexpr auto mbr_ptr{&SgFile::p_use_token_stream_to_improve_source_position_info};
16557 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16558 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_use_token_stream_to_improve_source_position_info>;
16559};
16560template <> struct describe_field_t<SgFile,bool,&SgFile::p_suppress_variable_declaration_normalization> {
16561 using parent = SgFile;
16562 using field_type = bool;
16563 static constexpr size_t position{114};
16564 static constexpr char const * const name{"suppress_variable_declaration_normalization"};
16565 static constexpr char const * const typestr{"bool"};
16566 static constexpr bool traverse{false};
16567 static constexpr auto mbr_ptr{&SgFile::p_suppress_variable_declaration_normalization};
16568 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16569 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_suppress_variable_declaration_normalization>;
16570};
16571template <> struct describe_field_t<SgFile,bool,&SgFile::p_edg_il_to_graphviz> {
16572 using parent = SgFile;
16573 using field_type = bool;
16574 static constexpr size_t position{115};
16575 static constexpr char const * const name{"edg_il_to_graphviz"};
16576 static constexpr char const * const typestr{"bool"};
16577 static constexpr bool traverse{false};
16578 static constexpr auto mbr_ptr{&SgFile::p_edg_il_to_graphviz};
16579 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16580 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_edg_il_to_graphviz>;
16581};
16582template <> struct describe_field_t<SgFile,bool,&SgFile::p_clang_il_to_graphviz> {
16583 using parent = SgFile;
16584 using field_type = bool;
16585 static constexpr size_t position{116};
16586 static constexpr char const * const name{"clang_il_to_graphviz"};
16587 static constexpr char const * const typestr{"bool"};
16588 static constexpr bool traverse{false};
16589 static constexpr auto mbr_ptr{&SgFile::p_clang_il_to_graphviz};
16590 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16591 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_clang_il_to_graphviz>;
16592};
16593template <> struct describe_field_t<SgFile,bool,&SgFile::p_no_optimize_flag_for_frontend> {
16594 using parent = SgFile;
16595 using field_type = bool;
16596 static constexpr size_t position{117};
16597 static constexpr char const * const name{"no_optimize_flag_for_frontend"};
16598 static constexpr char const * const typestr{"bool"};
16599 static constexpr bool traverse{false};
16600 static constexpr auto mbr_ptr{&SgFile::p_no_optimize_flag_for_frontend};
16601 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16602 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_no_optimize_flag_for_frontend>;
16603};
16604template <> struct describe_field_t<SgFile,bool,&SgFile::p_unparse_edg_normalized_method_ROSE_1392> {
16605 using parent = SgFile;
16606 using field_type = bool;
16607 static constexpr size_t position{118};
16608 static constexpr char const * const name{"unparse_edg_normalized_method_ROSE_1392"};
16609 static constexpr char const * const typestr{"bool"};
16610 static constexpr bool traverse{false};
16611 static constexpr auto mbr_ptr{&SgFile::p_unparse_edg_normalized_method_ROSE_1392};
16612 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16613 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_unparse_edg_normalized_method_ROSE_1392>;
16614};
16615template <> struct describe_field_t<SgFile,SgFile::standard_enum,&SgFile::p_standard> {
16616 using parent = SgFile;
16617 using field_type = SgFile::standard_enum;
16618 static constexpr size_t position{119};
16619 static constexpr char const * const name{"standard"};
16620 static constexpr char const * const typestr{"SgFile::standard_enum"};
16621 static constexpr bool traverse{false};
16622 static constexpr auto mbr_ptr{&SgFile::p_standard};
16623 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16624 using bind = Desc<SgFile, SgFile::standard_enum SgFile::*, &SgFile::p_standard>;
16625};
16626template <> struct describe_field_t<SgFile,bool,&SgFile::p_gnu_standard> {
16627 using parent = SgFile;
16628 using field_type = bool;
16629 static constexpr size_t position{120};
16630 static constexpr char const * const name{"gnu_standard"};
16631 static constexpr char const * const typestr{"bool"};
16632 static constexpr bool traverse{false};
16633 static constexpr auto mbr_ptr{&SgFile::p_gnu_standard};
16634 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16635 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_gnu_standard>;
16636};
16637template <> struct describe_field_t<SgFile,int,&SgFile::p_frontendErrorCode> {
16638 using parent = SgFile;
16639 using field_type = int;
16640 static constexpr size_t position{121};
16641 static constexpr char const * const name{"frontendErrorCode"};
16642 static constexpr char const * const typestr{"int"};
16643 static constexpr bool traverse{false};
16644 static constexpr auto mbr_ptr{&SgFile::p_frontendErrorCode};
16645 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16646 using bind = Desc<SgFile, int SgFile::*, &SgFile::p_frontendErrorCode>;
16647};
16648template <> struct describe_field_t<SgFile,int,&SgFile::p_javacErrorCode> {
16649 using parent = SgFile;
16650 using field_type = int;
16651 static constexpr size_t position{122};
16652 static constexpr char const * const name{"javacErrorCode"};
16653 static constexpr char const * const typestr{"int"};
16654 static constexpr bool traverse{false};
16655 static constexpr auto mbr_ptr{&SgFile::p_javacErrorCode};
16656 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16657 using bind = Desc<SgFile, int SgFile::*, &SgFile::p_javacErrorCode>;
16658};
16659template <> struct describe_field_t<SgFile,int,&SgFile::p_ecjErrorCode> {
16660 using parent = SgFile;
16661 using field_type = int;
16662 static constexpr size_t position{123};
16663 static constexpr char const * const name{"ecjErrorCode"};
16664 static constexpr char const * const typestr{"int"};
16665 static constexpr bool traverse{false};
16666 static constexpr auto mbr_ptr{&SgFile::p_ecjErrorCode};
16667 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16668 using bind = Desc<SgFile, int SgFile::*, &SgFile::p_ecjErrorCode>;
16669};
16670template <> struct describe_field_t<SgFile,int,&SgFile::p_midendErrorCode> {
16671 using parent = SgFile;
16672 using field_type = int;
16673 static constexpr size_t position{124};
16674 static constexpr char const * const name{"midendErrorCode"};
16675 static constexpr char const * const typestr{"int"};
16676 static constexpr bool traverse{false};
16677 static constexpr auto mbr_ptr{&SgFile::p_midendErrorCode};
16678 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16679 using bind = Desc<SgFile, int SgFile::*, &SgFile::p_midendErrorCode>;
16680};
16681template <> struct describe_field_t<SgFile,int,&SgFile::p_unparserErrorCode> {
16682 using parent = SgFile;
16683 using field_type = int;
16684 static constexpr size_t position{125};
16685 static constexpr char const * const name{"unparserErrorCode"};
16686 static constexpr char const * const typestr{"int"};
16687 static constexpr bool traverse{false};
16688 static constexpr auto mbr_ptr{&SgFile::p_unparserErrorCode};
16689 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16690 using bind = Desc<SgFile, int SgFile::*, &SgFile::p_unparserErrorCode>;
16691};
16692template <> struct describe_field_t<SgFile,int,&SgFile::p_backendCompilerErrorCode> {
16693 using parent = SgFile;
16694 using field_type = int;
16695 static constexpr size_t position{126};
16696 static constexpr char const * const name{"backendCompilerErrorCode"};
16697 static constexpr char const * const typestr{"int"};
16698 static constexpr bool traverse{false};
16699 static constexpr auto mbr_ptr{&SgFile::p_backendCompilerErrorCode};
16700 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16701 using bind = Desc<SgFile, int SgFile::*, &SgFile::p_backendCompilerErrorCode>;
16702};
16703template <> struct describe_field_t<SgFile,bool,&SgFile::p_unparsedFileFailedCompilation> {
16704 using parent = SgFile;
16705 using field_type = bool;
16706 static constexpr size_t position{127};
16707 static constexpr char const * const name{"unparsedFileFailedCompilation"};
16708 static constexpr char const * const typestr{"bool"};
16709 static constexpr bool traverse{false};
16710 static constexpr auto mbr_ptr{&SgFile::p_unparsedFileFailedCompilation};
16711 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16712 using bind = Desc<SgFile, bool SgFile::*, &SgFile::p_unparsedFileFailedCompilation>;
16713};
16714template <> struct describe_node_t<SgFile> {
16715 using node = SgFile;
16716 using base = SgSupport;
16717 static constexpr char const * const name{"File"};
16718 static constexpr unsigned long variant{419};
16719 static constexpr bool concrete{false};
16721 using fields_t = mp::List<describe_field_t<SgFile,Sg_File_Info*,&SgFile::p_startOfConstruct>, describe_field_t<SgFile,SgStringList,&SgFile::p_originalCommandLineArgumentList>, describe_field_t<SgFile,int,&SgFile::p_verbose>, describe_field_t<SgFile,bool,&SgFile::p_output_warnings>, describe_field_t<SgFile,bool,&SgFile::p_C_only>, describe_field_t<SgFile,bool,&SgFile::p_Cxx_only>, describe_field_t<SgFile,bool,&SgFile::p_Fortran_only>, describe_field_t<SgFile,bool,&SgFile::p_CoArrayFortran_only>, describe_field_t<SgFile,int,&SgFile::p_upc_threads>, describe_field_t<SgFile,bool,&SgFile::p_Java_only>, describe_field_t<SgFile,bool,&SgFile::p_Jvm_only>, describe_field_t<SgFile,bool,&SgFile::p_Jovial_only>, describe_field_t<SgFile,bool,&SgFile::p_PHP_only>, describe_field_t<SgFile,bool,&SgFile::p_Python_only>, describe_field_t<SgFile,bool,&SgFile::p_Cuda_only>, describe_field_t<SgFile,bool,&SgFile::p_OpenCL_only>, describe_field_t<SgFile,bool,&SgFile::p_Csharp_only>, describe_field_t<SgFile,bool,&SgFile::p_Ada_only>, describe_field_t<SgFile,bool,&SgFile::p_requires_C_preprocessor>, describe_field_t<SgFile,bool,&SgFile::p_binary_only>, describe_field_t<SgFile,SgFile::outputFormatOption_enum,&SgFile::p_inputFormat>, describe_field_t<SgFile,SgFile::outputFormatOption_enum,&SgFile::p_outputFormat>, describe_field_t<SgFile,SgFile::outputFormatOption_enum,&SgFile::p_backendCompileFormat>, describe_field_t<SgFile,bool,&SgFile::p_fortran_implicit_none>, describe_field_t<SgFile,bool,&SgFile::p_openmp>, describe_field_t<SgFile,bool,&SgFile::p_openmp_parse_only>, describe_field_t<SgFile,bool,&SgFile::p_openmp_ast_only>, describe_field_t<SgFile,bool,&SgFile::p_openmp_lowering>, describe_field_t<SgFile,bool,&SgFile::p_openacc>, describe_field_t<SgFile,bool,&SgFile::p_openacc_parse_only>, describe_field_t<SgFile,bool,&SgFile::p_openacc_ast_only>, describe_field_t<SgFile,bool,&SgFile::p_cray_pointer_support>, describe_field_t<SgFile,bool,&SgFile::p_failsafe>, describe_field_t<SgFile,bool,&SgFile::p_output_parser_actions>, describe_field_t<SgFile,bool,&SgFile::p_exit_after_parser>, describe_field_t<SgFile,bool,&SgFile::p_skip_syntax_check>, describe_field_t<SgFile,bool,&SgFile::p_skip_parser>, describe_field_t<SgFile,bool,&SgFile::p_relax_syntax_check>, describe_field_t<SgFile,bool,&SgFile::p_skip_translation_from_edg_ast_to_rose_ast>, describe_field_t<SgFile,bool,&SgFile::p_skip_transformation>, describe_field_t<SgFile,bool,&SgFile::p_skip_unparse>, describe_field_t<SgFile,bool,&SgFile::p_skipfinalCompileStep>, describe_field_t<SgFile,bool,&SgFile::p_unparse_includes>, describe_field_t<SgFile,bool,&SgFile::p_unparse_line_directives>, describe_field_t<SgFile,bool,&SgFile::p_unparse_function_calls_using_operator_syntax>, describe_field_t<SgFile,bool,&SgFile::p_unparse_function_calls_using_operator_names>, describe_field_t<SgFile,bool,&SgFile::p_unparse_instruction_addresses>, describe_field_t<SgFile,bool,&SgFile::p_unparse_raw_memory_contents>, describe_field_t<SgFile,bool,&SgFile::p_unparse_binary_file_format>, describe_field_t<SgFile,SgFile::languageOption_enum,&SgFile::p_outputLanguage>, describe_field_t<SgFile,SgFile::languageOption_enum,&SgFile::p_inputLanguage>, describe_field_t<SgFile,std::string,&SgFile::p_sourceFileNameWithPath>, describe_field_t<SgFile,std::string,&SgFile::p_sourceFileNameWithoutPath>, describe_field_t<SgFile,std::string,&SgFile::p_unparse_output_filename>, describe_field_t<SgFile,std::string,&SgFile::p_objectFileNameWithPath>, describe_field_t<SgFile,std::string,&SgFile::p_objectFileNameWithoutPath>, describe_field_t<SgFile,bool,&SgFile::p_useBackendOnly>, describe_field_t<SgFile,bool,&SgFile::p_compileOnly>, describe_field_t<SgFile,std::string,&SgFile::p_savedFrontendCommandLine>, describe_field_t<SgFile,bool,&SgFile::p_no_implicit_templates>, describe_field_t<SgFile,bool,&SgFile::p_no_implicit_inline_templates>, describe_field_t<SgFile,bool,&SgFile::p_skip_commentsAndDirectives>, describe_field_t<SgFile,bool,&SgFile::p_collectAllCommentsAndDirectives>, describe_field_t<SgFile,bool,&SgFile::p_translateCommentsAndDirectivesIntoAST>, describe_field_t<SgFile,bool,&SgFile::p_unparseHeaderFiles>, describe_field_t<SgFile,ROSEAttributesListContainerPtr,&SgFile::p_preprocessorDirectivesAndCommentsList>, describe_field_t<SgFile,AstAttributeMechanism*,&SgFile::p_attributeMechanism>, describe_field_t<SgFile,bool,&SgFile::p_KCC_frontend>, describe_field_t<SgFile,bool,&SgFile::p_new_frontend>, describe_field_t<SgFile,bool,&SgFile::p_disable_edg_backend>, describe_field_t<SgFile,bool,&SgFile::p_disable_sage_backend>, describe_field_t<SgFile,int,&SgFile::p_testingLevel>, describe_field_t<SgFile,bool,&SgFile::p_preinit_il>, describe_field_t<SgFile,bool,&SgFile::p_enable_cp_backend>, describe_field_t<SgFile,bool,&SgFile::p_markGeneratedFiles>, describe_field_t<SgFile,bool,&SgFile::p_negative_test>, describe_field_t<SgFile,bool,&SgFile::p_strict_language_handling>, describe_field_t<SgFile,bool,&SgFile::p_wave>, describe_field_t<SgFile,int,&SgFile::p_embedColorCodesInGeneratedCode>, describe_field_t<SgFile,int,&SgFile::p_generateSourcePositionCodes>, describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesCppFileExtension>, describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesFortranFileExtension>, describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesFortran77FileExtension>, describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesFortran90FileExtension>, describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesFortran95FileExtension>, describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesFortran2003FileExtension>, describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesFortran2008FileExtension>, describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesCoArrayFortranFileExtension>, describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesPHPFileExtension>, describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesPythonFileExtension>, describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesJavaFileExtension>, describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesJvmFileExtension>, describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesBinaryFileExtension>, describe_field_t<SgFile,bool,&SgFile::p_sourceFileTypeIsUnknown>, describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesCsharpFileExtension>, describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesAdaFileExtension>, describe_field_t<SgFile,bool,&SgFile::p_sourceFileUsesJovialFileExtension>, describe_field_t<SgFile,int,&SgFile::p_detect_dangling_pointers>, describe_field_t<SgFile,bool,&SgFile::p_experimental_flang_frontend>, describe_field_t<SgFile,bool,&SgFile::p_read_executable_file_format_only>, describe_field_t<SgFile,bool,&SgFile::p_visualize_executable_file_format_skip_symbols>, describe_field_t<SgFile,bool,&SgFile::p_visualize_dwarf_only>, describe_field_t<SgFile,bool,&SgFile::p_read_instructions_only>, describe_field_t<SgFile,SgStringList,&SgFile::p_libraryArchiveObjectFileNameList>, describe_field_t<SgFile,bool,&SgFile::p_isLibraryArchive>, describe_field_t<SgFile,bool,&SgFile::p_isObjectFile>, describe_field_t<SgFile,bool,&SgFile::p_unparse_tokens>, describe_field_t<SgFile,int,&SgFile::p_unparse_tokens_testing>, describe_field_t<SgFile,bool,&SgFile::p_unparse_using_leading_and_trailing_token_mappings>, describe_field_t<SgFile,bool,&SgFile::p_unparse_template_ast>, describe_field_t<SgFile,bool,&SgFile::p_skipAstConsistancyTests>, describe_field_t<SgFile,bool,&SgFile::p_multifile_support>, describe_field_t<SgFile,bool,&SgFile::p_optimization>, describe_field_t<SgFile,bool,&SgFile::p_use_token_stream_to_improve_source_position_info>, describe_field_t<SgFile,bool,&SgFile::p_suppress_variable_declaration_normalization>, describe_field_t<SgFile,bool,&SgFile::p_edg_il_to_graphviz>, describe_field_t<SgFile,bool,&SgFile::p_clang_il_to_graphviz>, describe_field_t<SgFile,bool,&SgFile::p_no_optimize_flag_for_frontend>, describe_field_t<SgFile,bool,&SgFile::p_unparse_edg_normalized_method_ROSE_1392>, describe_field_t<SgFile,SgFile::standard_enum,&SgFile::p_standard>, describe_field_t<SgFile,bool,&SgFile::p_gnu_standard>, describe_field_t<SgFile,int,&SgFile::p_frontendErrorCode>, describe_field_t<SgFile,int,&SgFile::p_javacErrorCode>, describe_field_t<SgFile,int,&SgFile::p_ecjErrorCode>, describe_field_t<SgFile,int,&SgFile::p_midendErrorCode>, describe_field_t<SgFile,int,&SgFile::p_unparserErrorCode>, describe_field_t<SgFile,int,&SgFile::p_backendCompilerErrorCode>, describe_field_t<SgFile,bool,&SgFile::p_unparsedFileFailedCompilation>>;
16722};
16723template <> struct node_from_variant_t<419> { using type = SgFile; };
16724
16725// Class: FileList
16726template <> struct describe_field_t<SgFileList,SgFilePtrList,&SgFileList::p_listOfFiles> {
16727 using parent = SgFileList;
16728 using field_type = SgFilePtrList;
16729 static constexpr size_t position{0};
16730 static constexpr char const * const name{"listOfFiles"};
16731 static constexpr char const * const typestr{"SgFilePtrList"};
16732 static constexpr bool traverse{true};
16733 static constexpr auto mbr_ptr{&SgFileList::p_listOfFiles};
16734 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16735 using bind = Desc<SgFileList, SgFilePtrList SgFileList::*, &SgFileList::p_listOfFiles>;
16736};
16737template <> struct describe_field_t<SgFileList,AstAttributeMechanism*,&SgFileList::p_attributeMechanism> {
16738 using parent = SgFileList;
16740 static constexpr size_t position{1};
16741 static constexpr char const * const name{"attributeMechanism"};
16742 static constexpr char const * const typestr{"AstAttributeMechanism*"};
16743 static constexpr bool traverse{false};
16744 static constexpr auto mbr_ptr{&SgFileList::p_attributeMechanism};
16745 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16746 using bind = Desc<SgFileList, AstAttributeMechanism* SgFileList::*, &SgFileList::p_attributeMechanism>;
16747};
16748template <> struct describe_node_t<SgFileList> {
16749 using node = SgFileList;
16750 using base = SgSupport;
16751 static constexpr char const * const name{"FileList"};
16752 static constexpr unsigned long variant{420};
16753 static constexpr bool concrete{true};
16754 using subclasses_t = mp::List<>;
16756};
16757template <> struct node_from_variant_t<420> { using type = SgFileList; };
16758
16759// Class: FloatVal
16761 using parent = SgFloatVal;
16762 using field_type = float;
16763 static constexpr size_t position{0};
16764 static constexpr char const * const name{"value"};
16765 static constexpr char const * const typestr{"float"};
16766 static constexpr bool traverse{false};
16767 static constexpr auto mbr_ptr{&SgFloatVal::p_value};
16768 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16769 using bind = Desc<SgFloatVal, float SgFloatVal::*, &SgFloatVal::p_value>;
16770};
16771template <> struct describe_field_t<SgFloatVal,std::string,&SgFloatVal::p_valueString> {
16772 using parent = SgFloatVal;
16773 using field_type = std::string;
16774 static constexpr size_t position{1};
16775 static constexpr char const * const name{"valueString"};
16776 static constexpr char const * const typestr{"std::string"};
16777 static constexpr bool traverse{false};
16778 static constexpr auto mbr_ptr{&SgFloatVal::p_valueString};
16779 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16780 using bind = Desc<SgFloatVal, std::string SgFloatVal::*, &SgFloatVal::p_valueString>;
16781};
16782template <> struct describe_node_t<SgFloatVal> {
16783 using node = SgFloatVal;
16784 using base = SgValueExp;
16785 static constexpr char const * const name{"FloatVal"};
16786 static constexpr unsigned long variant{421};
16787 static constexpr bool concrete{true};
16788 using subclasses_t = mp::List<>;
16790};
16791template <> struct node_from_variant_t<421> { using type = SgFloatVal; };
16792
16793// Class: Float128Val
16794template <> struct describe_field_t<SgFloat128Val,long double,&SgFloat128Val::p_value> {
16795 using parent = SgFloat128Val;
16796 using field_type = long double;
16797 static constexpr size_t position{0};
16798 static constexpr char const * const name{"value"};
16799 static constexpr char const * const typestr{"long double"};
16800 static constexpr bool traverse{false};
16801 static constexpr auto mbr_ptr{&SgFloat128Val::p_value};
16802 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16803 using bind = Desc<SgFloat128Val, long double SgFloat128Val::*, &SgFloat128Val::p_value>;
16804};
16805template <> struct describe_field_t<SgFloat128Val,std::string,&SgFloat128Val::p_valueString> {
16806 using parent = SgFloat128Val;
16807 using field_type = std::string;
16808 static constexpr size_t position{1};
16809 static constexpr char const * const name{"valueString"};
16810 static constexpr char const * const typestr{"std::string"};
16811 static constexpr bool traverse{false};
16812 static constexpr auto mbr_ptr{&SgFloat128Val::p_valueString};
16813 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16814 using bind = Desc<SgFloat128Val, std::string SgFloat128Val::*, &SgFloat128Val::p_valueString>;
16815};
16816template <> struct describe_node_t<SgFloat128Val> {
16817 using node = SgFloat128Val;
16818 using base = SgValueExp;
16819 static constexpr char const * const name{"Float128Val"};
16820 static constexpr unsigned long variant{422};
16821 static constexpr bool concrete{true};
16822 using subclasses_t = mp::List<>;
16824};
16825template <> struct node_from_variant_t<422> { using type = SgFloat128Val; };
16826
16827// Class: Float80Val
16828template <> struct describe_field_t<SgFloat80Val,long double,&SgFloat80Val::p_value> {
16829 using parent = SgFloat80Val;
16830 using field_type = long double;
16831 static constexpr size_t position{0};
16832 static constexpr char const * const name{"value"};
16833 static constexpr char const * const typestr{"long double"};
16834 static constexpr bool traverse{false};
16835 static constexpr auto mbr_ptr{&SgFloat80Val::p_value};
16836 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16837 using bind = Desc<SgFloat80Val, long double SgFloat80Val::*, &SgFloat80Val::p_value>;
16838};
16839template <> struct describe_field_t<SgFloat80Val,std::string,&SgFloat80Val::p_valueString> {
16840 using parent = SgFloat80Val;
16841 using field_type = std::string;
16842 static constexpr size_t position{1};
16843 static constexpr char const * const name{"valueString"};
16844 static constexpr char const * const typestr{"std::string"};
16845 static constexpr bool traverse{false};
16846 static constexpr auto mbr_ptr{&SgFloat80Val::p_valueString};
16847 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16848 using bind = Desc<SgFloat80Val, std::string SgFloat80Val::*, &SgFloat80Val::p_valueString>;
16849};
16850template <> struct describe_node_t<SgFloat80Val> {
16851 using node = SgFloat80Val;
16852 using base = SgValueExp;
16853 static constexpr char const * const name{"Float80Val"};
16854 static constexpr unsigned long variant{423};
16855 static constexpr bool concrete{true};
16856 using subclasses_t = mp::List<>;
16858};
16859template <> struct node_from_variant_t<423> { using type = SgFloat80Val; };
16860
16861// Class: FoldExpression
16862template <> struct describe_field_t<SgFoldExpression,SgExpression*,&SgFoldExpression::p_operands> {
16863 using parent = SgFoldExpression;
16864 using field_type = SgExpression*;
16865 static constexpr size_t position{0};
16866 static constexpr char const * const name{"operands"};
16867 static constexpr char const * const typestr{"SgExpression*"};
16868 static constexpr bool traverse{true};
16869 static constexpr auto mbr_ptr{&SgFoldExpression::p_operands};
16870 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16871 using bind = Desc<SgFoldExpression, SgExpression* SgFoldExpression::*, &SgFoldExpression::p_operands>;
16872};
16873template <> struct describe_field_t<SgFoldExpression,std::string,&SgFoldExpression::p_operator_token> {
16874 using parent = SgFoldExpression;
16875 using field_type = std::string;
16876 static constexpr size_t position{1};
16877 static constexpr char const * const name{"operator_token"};
16878 static constexpr char const * const typestr{"std::string"};
16879 static constexpr bool traverse{false};
16880 static constexpr auto mbr_ptr{&SgFoldExpression::p_operator_token};
16881 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16882 using bind = Desc<SgFoldExpression, std::string SgFoldExpression::*, &SgFoldExpression::p_operator_token>;
16883};
16884template <> struct describe_field_t<SgFoldExpression,bool,&SgFoldExpression::p_is_left_associative> {
16885 using parent = SgFoldExpression;
16886 using field_type = bool;
16887 static constexpr size_t position{2};
16888 static constexpr char const * const name{"is_left_associative"};
16889 static constexpr char const * const typestr{"bool"};
16890 static constexpr bool traverse{false};
16891 static constexpr auto mbr_ptr{&SgFoldExpression::p_is_left_associative};
16892 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16893 using bind = Desc<SgFoldExpression, bool SgFoldExpression::*, &SgFoldExpression::p_is_left_associative>;
16894};
16896 using node = SgFoldExpression;
16897 using base = SgExpression;
16898 static constexpr char const * const name{"FoldExpression"};
16899 static constexpr unsigned long variant{424};
16900 static constexpr bool concrete{true};
16901 using subclasses_t = mp::List<>;
16903};
16904template <> struct node_from_variant_t<424> { using type = SgFoldExpression; };
16905
16906// Class: FlushStatement
16908 using node = SgFlushStatement;
16909 using base = SgIOStatement;
16910 static constexpr char const * const name{"FlushStatement"};
16911 static constexpr unsigned long variant{425};
16912 static constexpr bool concrete{true};
16913 using subclasses_t = mp::List<>;
16914 using fields_t = mp::List<>;
16915};
16916template <> struct node_from_variant_t<425> { using type = SgFlushStatement; };
16917
16918// Class: ForAllStatement
16919template <> struct describe_field_t<SgForAllStatement,SgExprListExp*,&SgForAllStatement::p_forall_header> {
16920 using parent = SgForAllStatement;
16921 using field_type = SgExprListExp*;
16922 static constexpr size_t position{0};
16923 static constexpr char const * const name{"forall_header"};
16924 static constexpr char const * const typestr{"SgExprListExp*"};
16925 static constexpr bool traverse{true};
16926 static constexpr auto mbr_ptr{&SgForAllStatement::p_forall_header};
16927 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16928 using bind = Desc<SgForAllStatement, SgExprListExp* SgForAllStatement::*, &SgForAllStatement::p_forall_header>;
16929};
16930template <> struct describe_field_t<SgForAllStatement,SgBasicBlock*,&SgForAllStatement::p_body> {
16931 using parent = SgForAllStatement;
16932 using field_type = SgBasicBlock*;
16933 static constexpr size_t position{1};
16934 static constexpr char const * const name{"body"};
16935 static constexpr char const * const typestr{"SgBasicBlock*"};
16936 static constexpr bool traverse{true};
16937 static constexpr auto mbr_ptr{&SgForAllStatement::p_body};
16938 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16939 using bind = Desc<SgForAllStatement, SgBasicBlock* SgForAllStatement::*, &SgForAllStatement::p_body>;
16940};
16941template <> struct describe_field_t<SgForAllStatement,bool,&SgForAllStatement::p_has_end_statement> {
16942 using parent = SgForAllStatement;
16943 using field_type = bool;
16944 static constexpr size_t position{2};
16945 static constexpr char const * const name{"has_end_statement"};
16946 static constexpr char const * const typestr{"bool"};
16947 static constexpr bool traverse{false};
16948 static constexpr auto mbr_ptr{&SgForAllStatement::p_has_end_statement};
16949 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16950 using bind = Desc<SgForAllStatement, bool SgForAllStatement::*, &SgForAllStatement::p_has_end_statement>;
16951};
16952template <> struct describe_field_t<SgForAllStatement,std::string,&SgForAllStatement::p_string_label> {
16953 using parent = SgForAllStatement;
16954 using field_type = std::string;
16955 static constexpr size_t position{3};
16956 static constexpr char const * const name{"string_label"};
16957 static constexpr char const * const typestr{"std::string"};
16958 static constexpr bool traverse{false};
16959 static constexpr auto mbr_ptr{&SgForAllStatement::p_string_label};
16960 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16961 using bind = Desc<SgForAllStatement, std::string SgForAllStatement::*, &SgForAllStatement::p_string_label>;
16962};
16963template <> struct describe_field_t<SgForAllStatement,SgLabelRefExp*,&SgForAllStatement::p_end_numeric_label> {
16964 using parent = SgForAllStatement;
16965 using field_type = SgLabelRefExp*;
16966 static constexpr size_t position{4};
16967 static constexpr char const * const name{"end_numeric_label"};
16968 static constexpr char const * const typestr{"SgLabelRefExp*"};
16969 static constexpr bool traverse{false};
16970 static constexpr auto mbr_ptr{&SgForAllStatement::p_end_numeric_label};
16971 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16972 using bind = Desc<SgForAllStatement, SgLabelRefExp* SgForAllStatement::*, &SgForAllStatement::p_end_numeric_label>;
16973};
16974template <> struct describe_field_t<SgForAllStatement,SgForAllStatement::forall_statement_kind_enum,&SgForAllStatement::p_forall_statement_kind> {
16975 using parent = SgForAllStatement;
16977 static constexpr size_t position{5};
16978 static constexpr char const * const name{"forall_statement_kind"};
16979 static constexpr char const * const typestr{"SgForAllStatement::forall_statement_kind_enum"};
16980 static constexpr bool traverse{false};
16981 static constexpr auto mbr_ptr{&SgForAllStatement::p_forall_statement_kind};
16982 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
16983 using bind = Desc<SgForAllStatement, SgForAllStatement::forall_statement_kind_enum SgForAllStatement::*, &SgForAllStatement::p_forall_statement_kind>;
16984};
16994template <> struct node_from_variant_t<426> { using type = SgForAllStatement; };
16995
16996// Class: ForInitStatement
16998 using parent = SgForInitStatement;
16999 using field_type = SgStatementPtrList;
17000 static constexpr size_t position{0};
17001 static constexpr char const * const name{"init_stmt"};
17002 static constexpr char const * const typestr{"SgStatementPtrList"};
17003 static constexpr bool traverse{true};
17004 static constexpr auto mbr_ptr{&SgForInitStatement::p_init_stmt};
17005 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17006 using bind = Desc<SgForInitStatement, SgStatementPtrList SgForInitStatement::*, &SgForInitStatement::p_init_stmt>;
17007};
17009 using node = SgForInitStatement;
17010 using base = SgStatement;
17011 static constexpr char const * const name{"ForInitStatement"};
17012 static constexpr unsigned long variant{427};
17013 static constexpr bool concrete{true};
17014 using subclasses_t = mp::List<>;
17016};
17017template <> struct node_from_variant_t<427> { using type = SgForInitStatement; };
17018
17019// Class: ForStatement
17021 using parent = SgForStatement;
17023 static constexpr size_t position{0};
17024 static constexpr char const * const name{"for_init_stmt"};
17025 static constexpr char const * const typestr{"SgForInitStatement*"};
17026 static constexpr bool traverse{true};
17027 static constexpr auto mbr_ptr{&SgForStatement::p_for_init_stmt};
17028 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17029 using bind = Desc<SgForStatement, SgForInitStatement* SgForStatement::*, &SgForStatement::p_for_init_stmt>;
17030};
17031template <> struct describe_field_t<SgForStatement,SgStatement*,&SgForStatement::p_test> {
17032 using parent = SgForStatement;
17033 using field_type = SgStatement*;
17034 static constexpr size_t position{1};
17035 static constexpr char const * const name{"test"};
17036 static constexpr char const * const typestr{"SgStatement*"};
17037 static constexpr bool traverse{true};
17038 static constexpr auto mbr_ptr{&SgForStatement::p_test};
17039 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17040 using bind = Desc<SgForStatement, SgStatement* SgForStatement::*, &SgForStatement::p_test>;
17041};
17042template <> struct describe_field_t<SgForStatement,SgExpression*,&SgForStatement::p_increment> {
17043 using parent = SgForStatement;
17044 using field_type = SgExpression*;
17045 static constexpr size_t position{2};
17046 static constexpr char const * const name{"increment"};
17047 static constexpr char const * const typestr{"SgExpression*"};
17048 static constexpr bool traverse{true};
17049 static constexpr auto mbr_ptr{&SgForStatement::p_increment};
17050 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17051 using bind = Desc<SgForStatement, SgExpression* SgForStatement::*, &SgForStatement::p_increment>;
17052};
17054 using parent = SgForStatement;
17055 using field_type = SgStatement*;
17056 static constexpr size_t position{3};
17057 static constexpr char const * const name{"loop_body"};
17058 static constexpr char const * const typestr{"SgStatement*"};
17059 static constexpr bool traverse{true};
17060 static constexpr auto mbr_ptr{&SgForStatement::p_loop_body};
17061 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17062 using bind = Desc<SgForStatement, SgStatement* SgForStatement::*, &SgForStatement::p_loop_body>;
17063};
17065 using parent = SgForStatement;
17066 using field_type = SgStatement*;
17067 static constexpr size_t position{4};
17068 static constexpr char const * const name{"else_body"};
17069 static constexpr char const * const typestr{"SgStatement*"};
17070 static constexpr bool traverse{true};
17071 static constexpr auto mbr_ptr{&SgForStatement::p_else_body};
17072 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17073 using bind = Desc<SgForStatement, SgStatement* SgForStatement::*, &SgForStatement::p_else_body>;
17074};
17075template <> struct describe_field_t<SgForStatement,std::string,&SgForStatement::p_string_label> {
17076 using parent = SgForStatement;
17077 using field_type = std::string;
17078 static constexpr size_t position{5};
17079 static constexpr char const * const name{"string_label"};
17080 static constexpr char const * const typestr{"std::string"};
17081 static constexpr bool traverse{false};
17082 static constexpr auto mbr_ptr{&SgForStatement::p_string_label};
17083 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17084 using bind = Desc<SgForStatement, std::string SgForStatement::*, &SgForStatement::p_string_label>;
17085};
17095template <> struct node_from_variant_t<428> { using type = SgForStatement; };
17096
17097// Class: FormatItem
17098template <> struct describe_field_t<SgFormatItem,int,&SgFormatItem::p_repeat_specification> {
17099 using parent = SgFormatItem;
17100 using field_type = int;
17101 static constexpr size_t position{0};
17102 static constexpr char const * const name{"repeat_specification"};
17103 static constexpr char const * const typestr{"int"};
17104 static constexpr bool traverse{false};
17105 static constexpr auto mbr_ptr{&SgFormatItem::p_repeat_specification};
17106 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17107 using bind = Desc<SgFormatItem, int SgFormatItem::*, &SgFormatItem::p_repeat_specification>;
17108};
17109template <> struct describe_field_t<SgFormatItem,SgExpression*,&SgFormatItem::p_data> {
17110 using parent = SgFormatItem;
17111 using field_type = SgExpression*;
17112 static constexpr size_t position{1};
17113 static constexpr char const * const name{"data"};
17114 static constexpr char const * const typestr{"SgExpression*"};
17115 static constexpr bool traverse{false};
17116 static constexpr auto mbr_ptr{&SgFormatItem::p_data};
17117 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17118 using bind = Desc<SgFormatItem, SgExpression* SgFormatItem::*, &SgFormatItem::p_data>;
17119};
17120template <> struct describe_field_t<SgFormatItem,SgFormatItemList*,&SgFormatItem::p_format_item_list> {
17121 using parent = SgFormatItem;
17123 static constexpr size_t position{2};
17124 static constexpr char const * const name{"format_item_list"};
17125 static constexpr char const * const typestr{"SgFormatItemList*"};
17126 static constexpr bool traverse{false};
17127 static constexpr auto mbr_ptr{&SgFormatItem::p_format_item_list};
17128 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17129 using bind = Desc<SgFormatItem, SgFormatItemList* SgFormatItem::*, &SgFormatItem::p_format_item_list>;
17130};
17131template <> struct describe_node_t<SgFormatItem> {
17132 using node = SgFormatItem;
17133 using base = SgSupport;
17134 static constexpr char const * const name{"FormatItem"};
17135 static constexpr unsigned long variant{429};
17136 static constexpr bool concrete{true};
17137 using subclasses_t = mp::List<>;
17139};
17140template <> struct node_from_variant_t<429> { using type = SgFormatItem; };
17141
17142// Class: FormatItemList
17143template <> struct describe_field_t<SgFormatItemList,SgFormatItemPtrList,&SgFormatItemList::p_format_item_list> {
17144 using parent = SgFormatItemList;
17145 using field_type = SgFormatItemPtrList;
17146 static constexpr size_t position{0};
17147 static constexpr char const * const name{"format_item_list"};
17148 static constexpr char const * const typestr{"SgFormatItemPtrList"};
17149 static constexpr bool traverse{false};
17150 static constexpr auto mbr_ptr{&SgFormatItemList::p_format_item_list};
17151 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17152 using bind = Desc<SgFormatItemList, SgFormatItemPtrList SgFormatItemList::*, &SgFormatItemList::p_format_item_list>;
17153};
17155 using node = SgFormatItemList;
17156 using base = SgSupport;
17157 static constexpr char const * const name{"FormatItemList"};
17158 static constexpr unsigned long variant{430};
17159 static constexpr bool concrete{true};
17160 using subclasses_t = mp::List<>;
17162};
17163template <> struct node_from_variant_t<430> { using type = SgFormatItemList; };
17164
17165// Class: FormatStatement
17166template <> struct describe_field_t<SgFormatStatement,SgFormatItemList*,&SgFormatStatement::p_format_item_list> {
17167 using parent = SgFormatStatement;
17169 static constexpr size_t position{0};
17170 static constexpr char const * const name{"format_item_list"};
17171 static constexpr char const * const typestr{"SgFormatItemList*"};
17172 static constexpr bool traverse{false};
17173 static constexpr auto mbr_ptr{&SgFormatStatement::p_format_item_list};
17174 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17175 using bind = Desc<SgFormatStatement, SgFormatItemList* SgFormatStatement::*, &SgFormatStatement::p_format_item_list>;
17176};
17178 using node = SgFormatStatement;
17180 static constexpr char const * const name{"FormatStatement"};
17181 static constexpr unsigned long variant{431};
17182 static constexpr bool concrete{true};
17183 using subclasses_t = mp::List<>;
17185};
17186template <> struct node_from_variant_t<431> { using type = SgFormatStatement; };
17187
17188// Class: FortranDo
17189template <> struct describe_field_t<SgFortranDo,SgExpression*,&SgFortranDo::p_initialization> {
17190 using parent = SgFortranDo;
17191 using field_type = SgExpression*;
17192 static constexpr size_t position{0};
17193 static constexpr char const * const name{"initialization"};
17194 static constexpr char const * const typestr{"SgExpression*"};
17195 static constexpr bool traverse{true};
17196 static constexpr auto mbr_ptr{&SgFortranDo::p_initialization};
17197 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17198 using bind = Desc<SgFortranDo, SgExpression* SgFortranDo::*, &SgFortranDo::p_initialization>;
17199};
17200template <> struct describe_field_t<SgFortranDo,SgExpression*,&SgFortranDo::p_bound> {
17201 using parent = SgFortranDo;
17202 using field_type = SgExpression*;
17203 static constexpr size_t position{1};
17204 static constexpr char const * const name{"bound"};
17205 static constexpr char const * const typestr{"SgExpression*"};
17206 static constexpr bool traverse{true};
17207 static constexpr auto mbr_ptr{&SgFortranDo::p_bound};
17208 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17209 using bind = Desc<SgFortranDo, SgExpression* SgFortranDo::*, &SgFortranDo::p_bound>;
17210};
17211template <> struct describe_field_t<SgFortranDo,SgExpression*,&SgFortranDo::p_increment> {
17212 using parent = SgFortranDo;
17213 using field_type = SgExpression*;
17214 static constexpr size_t position{2};
17215 static constexpr char const * const name{"increment"};
17216 static constexpr char const * const typestr{"SgExpression*"};
17217 static constexpr bool traverse{true};
17218 static constexpr auto mbr_ptr{&SgFortranDo::p_increment};
17219 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17220 using bind = Desc<SgFortranDo, SgExpression* SgFortranDo::*, &SgFortranDo::p_increment>;
17221};
17222template <> struct describe_field_t<SgFortranDo,SgBasicBlock*,&SgFortranDo::p_body> {
17223 using parent = SgFortranDo;
17224 using field_type = SgBasicBlock*;
17225 static constexpr size_t position{3};
17226 static constexpr char const * const name{"body"};
17227 static constexpr char const * const typestr{"SgBasicBlock*"};
17228 static constexpr bool traverse{true};
17229 static constexpr auto mbr_ptr{&SgFortranDo::p_body};
17230 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17231 using bind = Desc<SgFortranDo, SgBasicBlock* SgFortranDo::*, &SgFortranDo::p_body>;
17232};
17233template <> struct describe_field_t<SgFortranDo,SgLabelRefExp*,&SgFortranDo::p_end_numeric_label> {
17234 using parent = SgFortranDo;
17235 using field_type = SgLabelRefExp*;
17236 static constexpr size_t position{4};
17237 static constexpr char const * const name{"end_numeric_label"};
17238 static constexpr char const * const typestr{"SgLabelRefExp*"};
17239 static constexpr bool traverse{false};
17240 static constexpr auto mbr_ptr{&SgFortranDo::p_end_numeric_label};
17241 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17242 using bind = Desc<SgFortranDo, SgLabelRefExp* SgFortranDo::*, &SgFortranDo::p_end_numeric_label>;
17243};
17244template <> struct describe_field_t<SgFortranDo,std::string,&SgFortranDo::p_string_label> {
17245 using parent = SgFortranDo;
17246 using field_type = std::string;
17247 static constexpr size_t position{5};
17248 static constexpr char const * const name{"string_label"};
17249 static constexpr char const * const typestr{"std::string"};
17250 static constexpr bool traverse{false};
17251 static constexpr auto mbr_ptr{&SgFortranDo::p_string_label};
17252 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17253 using bind = Desc<SgFortranDo, std::string SgFortranDo::*, &SgFortranDo::p_string_label>;
17254};
17255template <> struct describe_field_t<SgFortranDo,bool,&SgFortranDo::p_old_style> {
17256 using parent = SgFortranDo;
17257 using field_type = bool;
17258 static constexpr size_t position{6};
17259 static constexpr char const * const name{"old_style"};
17260 static constexpr char const * const typestr{"bool"};
17261 static constexpr bool traverse{false};
17262 static constexpr auto mbr_ptr{&SgFortranDo::p_old_style};
17263 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17264 using bind = Desc<SgFortranDo, bool SgFortranDo::*, &SgFortranDo::p_old_style>;
17265};
17266template <> struct describe_field_t<SgFortranDo,bool,&SgFortranDo::p_has_end_statement> {
17267 using parent = SgFortranDo;
17268 using field_type = bool;
17269 static constexpr size_t position{7};
17270 static constexpr char const * const name{"has_end_statement"};
17271 static constexpr char const * const typestr{"bool"};
17272 static constexpr bool traverse{false};
17273 static constexpr auto mbr_ptr{&SgFortranDo::p_has_end_statement};
17274 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17275 using bind = Desc<SgFortranDo, bool SgFortranDo::*, &SgFortranDo::p_has_end_statement>;
17276};
17286template <> struct node_from_variant_t<432> { using type = SgFortranDo; };
17287
17288// Class: FortranIncludeLine
17289template <> struct describe_field_t<SgFortranIncludeLine,std::string,&SgFortranIncludeLine::p_filename> {
17291 using field_type = std::string;
17292 static constexpr size_t position{0};
17293 static constexpr char const * const name{"filename"};
17294 static constexpr char const * const typestr{"std::string"};
17295 static constexpr bool traverse{false};
17296 static constexpr auto mbr_ptr{&SgFortranIncludeLine::p_filename};
17297 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17298 using bind = Desc<SgFortranIncludeLine, std::string SgFortranIncludeLine::*, &SgFortranIncludeLine::p_filename>;
17299};
17301 using node = SgFortranIncludeLine;
17303 static constexpr char const * const name{"FortranIncludeLine"};
17304 static constexpr unsigned long variant{433};
17305 static constexpr bool concrete{true};
17306 using subclasses_t = mp::List<>;
17308};
17309template <> struct node_from_variant_t<433> { using type = SgFortranIncludeLine; };
17310
17311// Class: FortranNonblockedDo
17312template <> struct describe_field_t<SgFortranNonblockedDo,SgStatement*,&SgFortranNonblockedDo::p_end_statement> {
17314 using field_type = SgStatement*;
17315 static constexpr size_t position{0};
17316 static constexpr char const * const name{"end_statement"};
17317 static constexpr char const * const typestr{"SgStatement*"};
17318 static constexpr bool traverse{false};
17319 static constexpr auto mbr_ptr{&SgFortranNonblockedDo::p_end_statement};
17320 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17321 using bind = Desc<SgFortranNonblockedDo, SgStatement* SgFortranNonblockedDo::*, &SgFortranNonblockedDo::p_end_statement>;
17322};
17325 using base = SgFortranDo;
17326 static constexpr char const * const name{"FortranNonblockedDo"};
17327 static constexpr unsigned long variant{434};
17328 static constexpr bool concrete{true};
17329 using subclasses_t = mp::List<>;
17331};
17332template <> struct node_from_variant_t<434> { using type = SgFortranNonblockedDo; };
17333
17334// Class: FuncDecl_attr
17336 using node = SgFuncDecl_attr;
17337 using base = SgBitAttribute;
17338 static constexpr char const * const name{"FuncDecl_attr"};
17339 static constexpr unsigned long variant{435};
17340 static constexpr bool concrete{true};
17341 using subclasses_t = mp::List<>;
17342 using fields_t = mp::List<>;
17343};
17344template <> struct node_from_variant_t<435> { using type = SgFuncDecl_attr; };
17345
17346// Class: FunctionCallExp
17347template <> struct describe_field_t<SgFunctionCallExp,bool,&SgFunctionCallExp::p_uses_operator_syntax> {
17348 using parent = SgFunctionCallExp;
17349 using field_type = bool;
17350 static constexpr size_t position{0};
17351 static constexpr char const * const name{"uses_operator_syntax"};
17352 static constexpr char const * const typestr{"bool"};
17353 static constexpr bool traverse{false};
17354 static constexpr auto mbr_ptr{&SgFunctionCallExp::p_uses_operator_syntax};
17355 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17356 using bind = Desc<SgFunctionCallExp, bool SgFunctionCallExp::*, &SgFunctionCallExp::p_uses_operator_syntax>;
17357};
17358template <> struct describe_field_t<SgFunctionCallExp,bool,&SgFunctionCallExp::p_usesObjectCallSyntax> {
17359 using parent = SgFunctionCallExp;
17360 using field_type = bool;
17361 static constexpr size_t position{1};
17362 static constexpr char const * const name{"usesObjectCallSyntax"};
17363 static constexpr char const * const typestr{"bool"};
17364 static constexpr bool traverse{false};
17365 static constexpr auto mbr_ptr{&SgFunctionCallExp::p_usesObjectCallSyntax};
17366 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17367 using bind = Desc<SgFunctionCallExp, bool SgFunctionCallExp::*, &SgFunctionCallExp::p_usesObjectCallSyntax>;
17368};
17370 using node = SgFunctionCallExp;
17371 using base = SgCallExpression;
17372 static constexpr char const * const name{"FunctionCallExp"};
17373 static constexpr unsigned long variant{436};
17374 static constexpr bool concrete{true};
17377};
17378template <> struct node_from_variant_t<436> { using type = SgFunctionCallExp; };
17379
17380// Class: FunctionDeclaration
17383 using field_type = SgName;
17384 static constexpr size_t position{0};
17385 static constexpr char const * const name{"name"};
17386 static constexpr char const * const typestr{"SgName"};
17387 static constexpr bool traverse{false};
17388 static constexpr auto mbr_ptr{&SgFunctionDeclaration::p_name};
17389 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17390 using bind = Desc<SgFunctionDeclaration, SgName SgFunctionDeclaration::*, &SgFunctionDeclaration::p_name>;
17391};
17392template <> struct describe_field_t<SgFunctionDeclaration,SgFunctionParameterList*,&SgFunctionDeclaration::p_parameterList> {
17395 static constexpr size_t position{1};
17396 static constexpr char const * const name{"parameterList"};
17397 static constexpr char const * const typestr{"SgFunctionParameterList*"};
17398 static constexpr bool traverse{true};
17399 static constexpr auto mbr_ptr{&SgFunctionDeclaration::p_parameterList};
17400 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17401 using bind = Desc<SgFunctionDeclaration, SgFunctionParameterList* SgFunctionDeclaration::*, &SgFunctionDeclaration::p_parameterList>;
17402};
17406 static constexpr size_t position{2};
17407 static constexpr char const * const name{"functionModifier"};
17408 static constexpr char const * const typestr{"SgFunctionModifier"};
17409 static constexpr bool traverse{false};
17410 static constexpr auto mbr_ptr{&SgFunctionDeclaration::p_functionModifier};
17411 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17412 using bind = Desc<SgFunctionDeclaration, SgFunctionModifier SgFunctionDeclaration::*, &SgFunctionDeclaration::p_functionModifier>;
17413};
17417 static constexpr size_t position{3};
17418 static constexpr char const * const name{"specialFunctionModifier"};
17419 static constexpr char const * const typestr{"SgSpecialFunctionModifier"};
17420 static constexpr bool traverse{false};
17421 static constexpr auto mbr_ptr{&SgFunctionDeclaration::p_specialFunctionModifier};
17422 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17423 using bind = Desc<SgFunctionDeclaration, SgSpecialFunctionModifier SgFunctionDeclaration::*, &SgFunctionDeclaration::p_specialFunctionModifier>;
17424};
17425template <> struct describe_field_t<SgFunctionDeclaration,SgTypePtrList,&SgFunctionDeclaration::p_exceptionSpecification> {
17427 using field_type = SgTypePtrList;
17428 static constexpr size_t position{4};
17429 static constexpr char const * const name{"exceptionSpecification"};
17430 static constexpr char const * const typestr{"SgTypePtrList"};
17431 static constexpr bool traverse{false};
17432 static constexpr auto mbr_ptr{&SgFunctionDeclaration::p_exceptionSpecification};
17433 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17434 using bind = Desc<SgFunctionDeclaration, SgTypePtrList SgFunctionDeclaration::*, &SgFunctionDeclaration::p_exceptionSpecification>;
17435};
17436template <> struct describe_field_t<SgFunctionDeclaration,bool,&SgFunctionDeclaration::p_named_in_end_statement> {
17438 using field_type = bool;
17439 static constexpr size_t position{5};
17440 static constexpr char const * const name{"named_in_end_statement"};
17441 static constexpr char const * const typestr{"bool"};
17442 static constexpr bool traverse{false};
17443 static constexpr auto mbr_ptr{&SgFunctionDeclaration::p_named_in_end_statement};
17444 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17445 using bind = Desc<SgFunctionDeclaration, bool SgFunctionDeclaration::*, &SgFunctionDeclaration::p_named_in_end_statement>;
17446};
17447template <> struct describe_field_t<SgFunctionDeclaration,std::string,&SgFunctionDeclaration::p_asm_name> {
17449 using field_type = std::string;
17450 static constexpr size_t position{6};
17451 static constexpr char const * const name{"asm_name"};
17452 static constexpr char const * const typestr{"std::string"};
17453 static constexpr bool traverse{false};
17454 static constexpr auto mbr_ptr{&SgFunctionDeclaration::p_asm_name};
17455 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17456 using bind = Desc<SgFunctionDeclaration, std::string SgFunctionDeclaration::*, &SgFunctionDeclaration::p_asm_name>;
17457};
17460 using field_type = SgExprListExp*;
17461 static constexpr size_t position{7};
17462 static constexpr char const * const name{"decoratorList"};
17463 static constexpr char const * const typestr{"SgExprListExp*"};
17464 static constexpr bool traverse{true};
17465 static constexpr auto mbr_ptr{&SgFunctionDeclaration::p_decoratorList};
17466 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17467 using bind = Desc<SgFunctionDeclaration, SgExprListExp* SgFunctionDeclaration::*, &SgFunctionDeclaration::p_decoratorList>;
17468};
17469template <> struct describe_field_t<SgFunctionDeclaration,bool,&SgFunctionDeclaration::p_ada_formal_subprogram_decl> {
17471 using field_type = bool;
17472 static constexpr size_t position{8};
17473 static constexpr char const * const name{"ada_formal_subprogram_decl"};
17474 static constexpr char const * const typestr{"bool"};
17475 static constexpr bool traverse{false};
17476 static constexpr auto mbr_ptr{&SgFunctionDeclaration::p_ada_formal_subprogram_decl};
17477 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17478 using bind = Desc<SgFunctionDeclaration, bool SgFunctionDeclaration::*, &SgFunctionDeclaration::p_ada_formal_subprogram_decl>;
17479};
17480template <> struct describe_field_t<SgFunctionDeclaration,bool,&SgFunctionDeclaration::p_ada_formal_decl_with_box> {
17482 using field_type = bool;
17483 static constexpr size_t position{9};
17484 static constexpr char const * const name{"ada_formal_decl_with_box"};
17485 static constexpr char const * const typestr{"bool"};
17486 static constexpr bool traverse{false};
17487 static constexpr auto mbr_ptr{&SgFunctionDeclaration::p_ada_formal_decl_with_box};
17488 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17489 using bind = Desc<SgFunctionDeclaration, bool SgFunctionDeclaration::*, &SgFunctionDeclaration::p_ada_formal_decl_with_box>;
17490};
17493 using field_type = SgFunctionType*;
17494 static constexpr size_t position{10};
17495 static constexpr char const * const name{"type"};
17496 static constexpr char const * const typestr{"SgFunctionType*"};
17497 static constexpr bool traverse{false};
17498 static constexpr auto mbr_ptr{&SgFunctionDeclaration::p_type};
17499 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17500 using bind = Desc<SgFunctionDeclaration, SgFunctionType* SgFunctionDeclaration::*, &SgFunctionDeclaration::p_type>;
17501};
17505 static constexpr size_t position{11};
17506 static constexpr char const * const name{"definition"};
17507 static constexpr char const * const typestr{"SgFunctionDefinition*"};
17508 static constexpr bool traverse{true};
17509 static constexpr auto mbr_ptr{&SgFunctionDeclaration::p_definition};
17510 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17511 using bind = Desc<SgFunctionDeclaration, SgFunctionDefinition* SgFunctionDeclaration::*, &SgFunctionDeclaration::p_definition>;
17512};
17515 using field_type = bool;
17516 static constexpr size_t position{12};
17517 static constexpr char const * const name{"oldStyleDefinition"};
17518 static constexpr char const * const typestr{"bool"};
17519 static constexpr bool traverse{false};
17520 static constexpr auto mbr_ptr{&SgFunctionDeclaration::p_oldStyleDefinition};
17521 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17522 using bind = Desc<SgFunctionDeclaration, bool SgFunctionDeclaration::*, &SgFunctionDeclaration::p_oldStyleDefinition>;
17523};
17524template <> struct describe_field_t<SgFunctionDeclaration,SgScopeStatement*,&SgFunctionDeclaration::p_scope> {
17527 static constexpr size_t position{13};
17528 static constexpr char const * const name{"scope"};
17529 static constexpr char const * const typestr{"SgScopeStatement*"};
17530 static constexpr bool traverse{false};
17531 static constexpr auto mbr_ptr{&SgFunctionDeclaration::p_scope};
17532 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17533 using bind = Desc<SgFunctionDeclaration, SgScopeStatement* SgFunctionDeclaration::*, &SgFunctionDeclaration::p_scope>;
17534};
17535template <> struct describe_field_t<SgFunctionDeclaration,SgDeclarationStatement::template_specialization_enum,&SgFunctionDeclaration::p_specialization> {
17538 static constexpr size_t position{14};
17539 static constexpr char const * const name{"specialization"};
17540 static constexpr char const * const typestr{"SgDeclarationStatement::template_specialization_enum"};
17541 static constexpr bool traverse{false};
17542 static constexpr auto mbr_ptr{&SgFunctionDeclaration::p_specialization};
17543 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17544 using bind = Desc<SgFunctionDeclaration, SgDeclarationStatement::template_specialization_enum SgFunctionDeclaration::*, &SgFunctionDeclaration::p_specialization>;
17545};
17546template <> struct describe_field_t<SgFunctionDeclaration,bool,&SgFunctionDeclaration::p_requiresNameQualificationOnReturnType> {
17548 using field_type = bool;
17549 static constexpr size_t position{15};
17550 static constexpr char const * const name{"requiresNameQualificationOnReturnType"};
17551 static constexpr char const * const typestr{"bool"};
17552 static constexpr bool traverse{false};
17553 static constexpr auto mbr_ptr{&SgFunctionDeclaration::p_requiresNameQualificationOnReturnType};
17554 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17555 using bind = Desc<SgFunctionDeclaration, bool SgFunctionDeclaration::*, &SgFunctionDeclaration::p_requiresNameQualificationOnReturnType>;
17556};
17557template <> struct describe_field_t<SgFunctionDeclaration,std::string,&SgFunctionDeclaration::p_gnu_extension_section> {
17559 using field_type = std::string;
17560 static constexpr size_t position{16};
17561 static constexpr char const * const name{"gnu_extension_section"};
17562 static constexpr char const * const typestr{"std::string"};
17563 static constexpr bool traverse{false};
17564 static constexpr auto mbr_ptr{&SgFunctionDeclaration::p_gnu_extension_section};
17565 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17566 using bind = Desc<SgFunctionDeclaration, std::string SgFunctionDeclaration::*, &SgFunctionDeclaration::p_gnu_extension_section>;
17567};
17568template <> struct describe_field_t<SgFunctionDeclaration,std::string,&SgFunctionDeclaration::p_gnu_extension_alias> {
17570 using field_type = std::string;
17571 static constexpr size_t position{17};
17572 static constexpr char const * const name{"gnu_extension_alias"};
17573 static constexpr char const * const typestr{"std::string"};
17574 static constexpr bool traverse{false};
17575 static constexpr auto mbr_ptr{&SgFunctionDeclaration::p_gnu_extension_alias};
17576 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17577 using bind = Desc<SgFunctionDeclaration, std::string SgFunctionDeclaration::*, &SgFunctionDeclaration::p_gnu_extension_alias>;
17578};
17579template <> struct describe_field_t<SgFunctionDeclaration,SgDeclarationStatement::gnu_extension_visability_attribute_enum,&SgFunctionDeclaration::p_gnu_extension_visability> {
17582 static constexpr size_t position{18};
17583 static constexpr char const * const name{"gnu_extension_visability"};
17584 static constexpr char const * const typestr{"SgDeclarationStatement::gnu_extension_visability_attribute_enum"};
17585 static constexpr bool traverse{false};
17586 static constexpr auto mbr_ptr{&SgFunctionDeclaration::p_gnu_extension_visability};
17587 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17588 using bind = Desc<SgFunctionDeclaration, SgDeclarationStatement::gnu_extension_visability_attribute_enum SgFunctionDeclaration::*, &SgFunctionDeclaration::p_gnu_extension_visability>;
17589};
17590template <> struct describe_field_t<SgFunctionDeclaration,int,&SgFunctionDeclaration::p_name_qualification_length> {
17592 using field_type = int;
17593 static constexpr size_t position{19};
17594 static constexpr char const * const name{"name_qualification_length"};
17595 static constexpr char const * const typestr{"int"};
17596 static constexpr bool traverse{false};
17597 static constexpr auto mbr_ptr{&SgFunctionDeclaration::p_name_qualification_length};
17598 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17599 using bind = Desc<SgFunctionDeclaration, int SgFunctionDeclaration::*, &SgFunctionDeclaration::p_name_qualification_length>;
17600};
17601template <> struct describe_field_t<SgFunctionDeclaration,bool,&SgFunctionDeclaration::p_type_elaboration_required> {
17603 using field_type = bool;
17604 static constexpr size_t position{20};
17605 static constexpr char const * const name{"type_elaboration_required"};
17606 static constexpr char const * const typestr{"bool"};
17607 static constexpr bool traverse{false};
17608 static constexpr auto mbr_ptr{&SgFunctionDeclaration::p_type_elaboration_required};
17609 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17610 using bind = Desc<SgFunctionDeclaration, bool SgFunctionDeclaration::*, &SgFunctionDeclaration::p_type_elaboration_required>;
17611};
17612template <> struct describe_field_t<SgFunctionDeclaration,bool,&SgFunctionDeclaration::p_global_qualification_required> {
17614 using field_type = bool;
17615 static constexpr size_t position{21};
17616 static constexpr char const * const name{"global_qualification_required"};
17617 static constexpr char const * const typestr{"bool"};
17618 static constexpr bool traverse{false};
17619 static constexpr auto mbr_ptr{&SgFunctionDeclaration::p_global_qualification_required};
17620 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17621 using bind = Desc<SgFunctionDeclaration, bool SgFunctionDeclaration::*, &SgFunctionDeclaration::p_global_qualification_required>;
17622};
17623template <> struct describe_field_t<SgFunctionDeclaration,int,&SgFunctionDeclaration::p_name_qualification_length_for_return_type> {
17625 using field_type = int;
17626 static constexpr size_t position{22};
17627 static constexpr char const * const name{"name_qualification_length_for_return_type"};
17628 static constexpr char const * const typestr{"int"};
17629 static constexpr bool traverse{false};
17630 static constexpr auto mbr_ptr{&SgFunctionDeclaration::p_name_qualification_length_for_return_type};
17631 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17632 using bind = Desc<SgFunctionDeclaration, int SgFunctionDeclaration::*, &SgFunctionDeclaration::p_name_qualification_length_for_return_type>;
17633};
17634template <> struct describe_field_t<SgFunctionDeclaration,bool,&SgFunctionDeclaration::p_type_elaboration_required_for_return_type> {
17636 using field_type = bool;
17637 static constexpr size_t position{23};
17638 static constexpr char const * const name{"type_elaboration_required_for_return_type"};
17639 static constexpr char const * const typestr{"bool"};
17640 static constexpr bool traverse{false};
17641 static constexpr auto mbr_ptr{&SgFunctionDeclaration::p_type_elaboration_required_for_return_type};
17642 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17643 using bind = Desc<SgFunctionDeclaration, bool SgFunctionDeclaration::*, &SgFunctionDeclaration::p_type_elaboration_required_for_return_type>;
17644};
17645template <> struct describe_field_t<SgFunctionDeclaration,bool,&SgFunctionDeclaration::p_global_qualification_required_for_return_type> {
17647 using field_type = bool;
17648 static constexpr size_t position{24};
17649 static constexpr char const * const name{"global_qualification_required_for_return_type"};
17650 static constexpr char const * const typestr{"bool"};
17651 static constexpr bool traverse{false};
17652 static constexpr auto mbr_ptr{&SgFunctionDeclaration::p_global_qualification_required_for_return_type};
17653 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17654 using bind = Desc<SgFunctionDeclaration, bool SgFunctionDeclaration::*, &SgFunctionDeclaration::p_global_qualification_required_for_return_type>;
17655};
17656template <> struct describe_field_t<SgFunctionDeclaration,bool,&SgFunctionDeclaration::p_prototypeIsWithoutParameters> {
17658 using field_type = bool;
17659 static constexpr size_t position{25};
17660 static constexpr char const * const name{"prototypeIsWithoutParameters"};
17661 static constexpr char const * const typestr{"bool"};
17662 static constexpr bool traverse{false};
17663 static constexpr auto mbr_ptr{&SgFunctionDeclaration::p_prototypeIsWithoutParameters};
17664 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17665 using bind = Desc<SgFunctionDeclaration, bool SgFunctionDeclaration::*, &SgFunctionDeclaration::p_prototypeIsWithoutParameters>;
17666};
17667template <> struct describe_field_t<SgFunctionDeclaration,int,&SgFunctionDeclaration::p_gnu_regparm_attribute> {
17669 using field_type = int;
17670 static constexpr size_t position{26};
17671 static constexpr char const * const name{"gnu_regparm_attribute"};
17672 static constexpr char const * const typestr{"int"};
17673 static constexpr bool traverse{false};
17674 static constexpr auto mbr_ptr{&SgFunctionDeclaration::p_gnu_regparm_attribute};
17675 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17676 using bind = Desc<SgFunctionDeclaration, int SgFunctionDeclaration::*, &SgFunctionDeclaration::p_gnu_regparm_attribute>;
17677};
17678template <> struct describe_field_t<SgFunctionDeclaration,SgFunctionType*,&SgFunctionDeclaration::p_type_syntax> {
17680 using field_type = SgFunctionType*;
17681 static constexpr size_t position{27};
17682 static constexpr char const * const name{"type_syntax"};
17683 static constexpr char const * const typestr{"SgFunctionType*"};
17684 static constexpr bool traverse{false};
17685 static constexpr auto mbr_ptr{&SgFunctionDeclaration::p_type_syntax};
17686 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17687 using bind = Desc<SgFunctionDeclaration, SgFunctionType* SgFunctionDeclaration::*, &SgFunctionDeclaration::p_type_syntax>;
17688};
17689template <> struct describe_field_t<SgFunctionDeclaration,bool,&SgFunctionDeclaration::p_type_syntax_is_available> {
17691 using field_type = bool;
17692 static constexpr size_t position{28};
17693 static constexpr char const * const name{"type_syntax_is_available"};
17694 static constexpr char const * const typestr{"bool"};
17695 static constexpr bool traverse{false};
17696 static constexpr auto mbr_ptr{&SgFunctionDeclaration::p_type_syntax_is_available};
17697 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17698 using bind = Desc<SgFunctionDeclaration, bool SgFunctionDeclaration::*, &SgFunctionDeclaration::p_type_syntax_is_available>;
17699};
17700template <> struct describe_field_t<SgFunctionDeclaration,SgFunctionParameterList*,&SgFunctionDeclaration::p_parameterList_syntax> {
17703 static constexpr size_t position{29};
17704 static constexpr char const * const name{"parameterList_syntax"};
17705 static constexpr char const * const typestr{"SgFunctionParameterList*"};
17706 static constexpr bool traverse{false};
17707 static constexpr auto mbr_ptr{&SgFunctionDeclaration::p_parameterList_syntax};
17708 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17709 using bind = Desc<SgFunctionDeclaration, SgFunctionParameterList* SgFunctionDeclaration::*, &SgFunctionDeclaration::p_parameterList_syntax>;
17710};
17711template <> struct describe_field_t<SgFunctionDeclaration,bool,&SgFunctionDeclaration::p_using_C11_Noreturn_keyword> {
17713 using field_type = bool;
17714 static constexpr size_t position{30};
17715 static constexpr char const * const name{"using_C11_Noreturn_keyword"};
17716 static constexpr char const * const typestr{"bool"};
17717 static constexpr bool traverse{false};
17718 static constexpr auto mbr_ptr{&SgFunctionDeclaration::p_using_C11_Noreturn_keyword};
17719 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17720 using bind = Desc<SgFunctionDeclaration, bool SgFunctionDeclaration::*, &SgFunctionDeclaration::p_using_C11_Noreturn_keyword>;
17721};
17722template <> struct describe_field_t<SgFunctionDeclaration,bool,&SgFunctionDeclaration::p_is_constexpr> {
17724 using field_type = bool;
17725 static constexpr size_t position{31};
17726 static constexpr char const * const name{"is_constexpr"};
17727 static constexpr char const * const typestr{"bool"};
17728 static constexpr bool traverse{false};
17729 static constexpr auto mbr_ptr{&SgFunctionDeclaration::p_is_constexpr};
17730 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17731 using bind = Desc<SgFunctionDeclaration, bool SgFunctionDeclaration::*, &SgFunctionDeclaration::p_is_constexpr>;
17732};
17733template <> struct describe_field_t<SgFunctionDeclaration,bool,&SgFunctionDeclaration::p_using_new_function_return_type_syntax> {
17735 using field_type = bool;
17736 static constexpr size_t position{32};
17737 static constexpr char const * const name{"using_new_function_return_type_syntax"};
17738 static constexpr char const * const typestr{"bool"};
17739 static constexpr bool traverse{false};
17740 static constexpr auto mbr_ptr{&SgFunctionDeclaration::p_using_new_function_return_type_syntax};
17741 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17742 using bind = Desc<SgFunctionDeclaration, bool SgFunctionDeclaration::*, &SgFunctionDeclaration::p_using_new_function_return_type_syntax>;
17743};
17744template <> struct describe_field_t<SgFunctionDeclaration,SgFunctionParameterScope*,&SgFunctionDeclaration::p_functionParameterScope> {
17747 static constexpr size_t position{33};
17748 static constexpr char const * const name{"functionParameterScope"};
17749 static constexpr char const * const typestr{"SgFunctionParameterScope*"};
17750 static constexpr bool traverse{false};
17751 static constexpr auto mbr_ptr{&SgFunctionDeclaration::p_functionParameterScope};
17752 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17753 using bind = Desc<SgFunctionDeclaration, SgFunctionParameterScope* SgFunctionDeclaration::*, &SgFunctionDeclaration::p_functionParameterScope>;
17754};
17755template <> struct describe_field_t<SgFunctionDeclaration,bool,&SgFunctionDeclaration::p_marked_as_edg_normalization> {
17757 using field_type = bool;
17758 static constexpr size_t position{34};
17759 static constexpr char const * const name{"marked_as_edg_normalization"};
17760 static constexpr char const * const typestr{"bool"};
17761 static constexpr bool traverse{false};
17762 static constexpr auto mbr_ptr{&SgFunctionDeclaration::p_marked_as_edg_normalization};
17763 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17764 using bind = Desc<SgFunctionDeclaration, bool SgFunctionDeclaration::*, &SgFunctionDeclaration::p_marked_as_edg_normalization>;
17765};
17766template <> struct describe_field_t<SgFunctionDeclaration,bool,&SgFunctionDeclaration::p_is_implicit_function> {
17768 using field_type = bool;
17769 static constexpr size_t position{35};
17770 static constexpr char const * const name{"is_implicit_function"};
17771 static constexpr char const * const typestr{"bool"};
17772 static constexpr bool traverse{false};
17773 static constexpr auto mbr_ptr{&SgFunctionDeclaration::p_is_implicit_function};
17774 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17775 using bind = Desc<SgFunctionDeclaration, bool SgFunctionDeclaration::*, &SgFunctionDeclaration::p_is_implicit_function>;
17776};
17780 static constexpr char const * const name{"FunctionDeclaration"};
17781 static constexpr unsigned long variant{437};
17782 static constexpr bool concrete{true};
17784 using fields_t = mp::List<describe_field_t<SgFunctionDeclaration,SgName,&SgFunctionDeclaration::p_name>, describe_field_t<SgFunctionDeclaration,SgFunctionParameterList*,&SgFunctionDeclaration::p_parameterList>, describe_field_t<SgFunctionDeclaration,SgFunctionModifier,&SgFunctionDeclaration::p_functionModifier>, describe_field_t<SgFunctionDeclaration,SgSpecialFunctionModifier,&SgFunctionDeclaration::p_specialFunctionModifier>, describe_field_t<SgFunctionDeclaration,SgTypePtrList,&SgFunctionDeclaration::p_exceptionSpecification>, describe_field_t<SgFunctionDeclaration,bool,&SgFunctionDeclaration::p_named_in_end_statement>, describe_field_t<SgFunctionDeclaration,std::string,&SgFunctionDeclaration::p_asm_name>, describe_field_t<SgFunctionDeclaration,SgExprListExp*,&SgFunctionDeclaration::p_decoratorList>, describe_field_t<SgFunctionDeclaration,bool,&SgFunctionDeclaration::p_ada_formal_subprogram_decl>, describe_field_t<SgFunctionDeclaration,bool,&SgFunctionDeclaration::p_ada_formal_decl_with_box>, describe_field_t<SgFunctionDeclaration,SgFunctionType*,&SgFunctionDeclaration::p_type>, describe_field_t<SgFunctionDeclaration,SgFunctionDefinition*,&SgFunctionDeclaration::p_definition>, describe_field_t<SgFunctionDeclaration,bool,&SgFunctionDeclaration::p_oldStyleDefinition>, describe_field_t<SgFunctionDeclaration,SgScopeStatement*,&SgFunctionDeclaration::p_scope>, describe_field_t<SgFunctionDeclaration,SgDeclarationStatement::template_specialization_enum,&SgFunctionDeclaration::p_specialization>, describe_field_t<SgFunctionDeclaration,bool,&SgFunctionDeclaration::p_requiresNameQualificationOnReturnType>, describe_field_t<SgFunctionDeclaration,std::string,&SgFunctionDeclaration::p_gnu_extension_section>, describe_field_t<SgFunctionDeclaration,std::string,&SgFunctionDeclaration::p_gnu_extension_alias>, describe_field_t<SgFunctionDeclaration,SgDeclarationStatement::gnu_extension_visability_attribute_enum,&SgFunctionDeclaration::p_gnu_extension_visability>, describe_field_t<SgFunctionDeclaration,int,&SgFunctionDeclaration::p_name_qualification_length>, describe_field_t<SgFunctionDeclaration,bool,&SgFunctionDeclaration::p_type_elaboration_required>, describe_field_t<SgFunctionDeclaration,bool,&SgFunctionDeclaration::p_global_qualification_required>, describe_field_t<SgFunctionDeclaration,int,&SgFunctionDeclaration::p_name_qualification_length_for_return_type>, describe_field_t<SgFunctionDeclaration,bool,&SgFunctionDeclaration::p_type_elaboration_required_for_return_type>, describe_field_t<SgFunctionDeclaration,bool,&SgFunctionDeclaration::p_global_qualification_required_for_return_type>, describe_field_t<SgFunctionDeclaration,bool,&SgFunctionDeclaration::p_prototypeIsWithoutParameters>, describe_field_t<SgFunctionDeclaration,int,&SgFunctionDeclaration::p_gnu_regparm_attribute>, describe_field_t<SgFunctionDeclaration,SgFunctionType*,&SgFunctionDeclaration::p_type_syntax>, describe_field_t<SgFunctionDeclaration,bool,&SgFunctionDeclaration::p_type_syntax_is_available>, describe_field_t<SgFunctionDeclaration,SgFunctionParameterList*,&SgFunctionDeclaration::p_parameterList_syntax>, describe_field_t<SgFunctionDeclaration,bool,&SgFunctionDeclaration::p_using_C11_Noreturn_keyword>, describe_field_t<SgFunctionDeclaration,bool,&SgFunctionDeclaration::p_is_constexpr>, describe_field_t<SgFunctionDeclaration,bool,&SgFunctionDeclaration::p_using_new_function_return_type_syntax>, describe_field_t<SgFunctionDeclaration,SgFunctionParameterScope*,&SgFunctionDeclaration::p_functionParameterScope>, describe_field_t<SgFunctionDeclaration,bool,&SgFunctionDeclaration::p_marked_as_edg_normalization>, describe_field_t<SgFunctionDeclaration,bool,&SgFunctionDeclaration::p_is_implicit_function>>;
17785};
17786template <> struct node_from_variant_t<437> { using type = SgFunctionDeclaration; };
17787
17788// Class: FunctionDefinition
17791 using field_type = SgBasicBlock*;
17792 static constexpr size_t position{0};
17793 static constexpr char const * const name{"body"};
17794 static constexpr char const * const typestr{"SgBasicBlock*"};
17795 static constexpr bool traverse{true};
17796 static constexpr auto mbr_ptr{&SgFunctionDefinition::p_body};
17797 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17798 using bind = Desc<SgFunctionDefinition, SgBasicBlock* SgFunctionDefinition::*, &SgFunctionDefinition::p_body>;
17799};
17800template <> struct describe_field_t<SgFunctionDefinition,std::map<SgNode*,int>,&SgFunctionDefinition::p_scope_number_list> {
17802 using field_type = std::map<SgNode*,int>;
17803 static constexpr size_t position{1};
17804 static constexpr char const * const name{"scope_number_list"};
17805 static constexpr char const * const typestr{"std::map<SgNode*,int>"};
17806 static constexpr bool traverse{false};
17807 static constexpr auto mbr_ptr{&SgFunctionDefinition::p_scope_number_list};
17808 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17809 using bind = Desc<SgFunctionDefinition, std::map<SgNode*,int> SgFunctionDefinition::*, &SgFunctionDefinition::p_scope_number_list>;
17810};
17812 using node = SgFunctionDefinition;
17813 using base = SgScopeStatement;
17814 static constexpr char const * const name{"FunctionDefinition"};
17815 static constexpr unsigned long variant{438};
17816 static constexpr bool concrete{true};
17819};
17820template <> struct node_from_variant_t<438> { using type = SgFunctionDefinition; };
17821
17822// Class: FunctionParameterScope
17823template <> struct describe_field_t<SgFunctionParameterScope,SgDeclarationStatementPtrList,&SgFunctionParameterScope::p_declarations> {
17825 using field_type = SgDeclarationStatementPtrList;
17826 static constexpr size_t position{0};
17827 static constexpr char const * const name{"declarations"};
17828 static constexpr char const * const typestr{"SgDeclarationStatementPtrList"};
17829 static constexpr bool traverse{true};
17830 static constexpr auto mbr_ptr{&SgFunctionParameterScope::p_declarations};
17831 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17832 using bind = Desc<SgFunctionParameterScope, SgDeclarationStatementPtrList SgFunctionParameterScope::*, &SgFunctionParameterScope::p_declarations>;
17833};
17836 using base = SgScopeStatement;
17837 static constexpr char const * const name{"FunctionParameterScope"};
17838 static constexpr unsigned long variant{439};
17839 static constexpr bool concrete{true};
17840 using subclasses_t = mp::List<>;
17842};
17843template <> struct node_from_variant_t<439> { using type = SgFunctionParameterScope; };
17844
17845// Class: FunctionModifier
17846template <> struct describe_field_t<SgFunctionModifier,SgBitVector,&SgFunctionModifier::p_modifierVector> {
17847 using parent = SgFunctionModifier;
17848 using field_type = SgBitVector;
17849 static constexpr size_t position{0};
17850 static constexpr char const * const name{"modifierVector"};
17851 static constexpr char const * const typestr{"SgBitVector"};
17852 static constexpr bool traverse{false};
17853 static constexpr auto mbr_ptr{&SgFunctionModifier::p_modifierVector};
17854 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17855 using bind = Desc<SgFunctionModifier, SgBitVector SgFunctionModifier::*, &SgFunctionModifier::p_modifierVector>;
17856};
17857template <> struct describe_field_t<SgFunctionModifier,unsigned long int,&SgFunctionModifier::p_gnu_attribute_constructor_destructor_priority> {
17858 using parent = SgFunctionModifier;
17859 using field_type = unsigned long int;
17860 static constexpr size_t position{1};
17861 static constexpr char const * const name{"gnu_attribute_constructor_destructor_priority"};
17862 static constexpr char const * const typestr{"unsigned long int"};
17863 static constexpr bool traverse{false};
17864 static constexpr auto mbr_ptr{&SgFunctionModifier::p_gnu_attribute_constructor_destructor_priority};
17865 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17866 using bind = Desc<SgFunctionModifier, unsigned long int SgFunctionModifier::*, &SgFunctionModifier::p_gnu_attribute_constructor_destructor_priority>;
17867};
17868template <> struct describe_field_t<SgFunctionModifier,std::string,&SgFunctionModifier::p_gnu_attribute_named_weak_reference> {
17869 using parent = SgFunctionModifier;
17870 using field_type = std::string;
17871 static constexpr size_t position{2};
17872 static constexpr char const * const name{"gnu_attribute_named_weak_reference"};
17873 static constexpr char const * const typestr{"std::string"};
17874 static constexpr bool traverse{false};
17875 static constexpr auto mbr_ptr{&SgFunctionModifier::p_gnu_attribute_named_weak_reference};
17876 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17877 using bind = Desc<SgFunctionModifier, std::string SgFunctionModifier::*, &SgFunctionModifier::p_gnu_attribute_named_weak_reference>;
17878};
17879template <> struct describe_field_t<SgFunctionModifier,std::string,&SgFunctionModifier::p_gnu_attribute_named_alias> {
17880 using parent = SgFunctionModifier;
17881 using field_type = std::string;
17882 static constexpr size_t position{3};
17883 static constexpr char const * const name{"gnu_attribute_named_alias"};
17884 static constexpr char const * const typestr{"std::string"};
17885 static constexpr bool traverse{false};
17886 static constexpr auto mbr_ptr{&SgFunctionModifier::p_gnu_attribute_named_alias};
17887 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17888 using bind = Desc<SgFunctionModifier, std::string SgFunctionModifier::*, &SgFunctionModifier::p_gnu_attribute_named_alias>;
17889};
17890template <> struct describe_field_t<SgFunctionModifier,SgType *,&SgFunctionModifier::p_opencl_vec_type> {
17891 using parent = SgFunctionModifier;
17892 using field_type = SgType *;
17893 static constexpr size_t position{4};
17894 static constexpr char const * const name{"opencl_vec_type"};
17895 static constexpr char const * const typestr{"SgType *"};
17896 static constexpr bool traverse{false};
17897 static constexpr auto mbr_ptr{&SgFunctionModifier::p_opencl_vec_type};
17898 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17899 using bind = Desc<SgFunctionModifier, SgType * SgFunctionModifier::*, &SgFunctionModifier::p_opencl_vec_type>;
17900};
17901template <> struct describe_field_t<SgFunctionModifier,SgFunctionModifier::opencl_work_group_size_t,&SgFunctionModifier::p_opencl_work_group_size> {
17902 using parent = SgFunctionModifier;
17904 static constexpr size_t position{5};
17905 static constexpr char const * const name{"opencl_work_group_size"};
17906 static constexpr char const * const typestr{"SgFunctionModifier::opencl_work_group_size_t"};
17907 static constexpr bool traverse{false};
17908 static constexpr auto mbr_ptr{&SgFunctionModifier::p_opencl_work_group_size};
17909 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17910 using bind = Desc<SgFunctionModifier, SgFunctionModifier::opencl_work_group_size_t SgFunctionModifier::*, &SgFunctionModifier::p_opencl_work_group_size>;
17911};
17921template <> struct node_from_variant_t<440> { using type = SgFunctionModifier; };
17922
17923// Class: FunctionParameterList
17924template <> struct describe_field_t<SgFunctionParameterList,SgInitializedNamePtrList,&SgFunctionParameterList::p_args> {
17926 using field_type = SgInitializedNamePtrList;
17927 static constexpr size_t position{0};
17928 static constexpr char const * const name{"args"};
17929 static constexpr char const * const typestr{"SgInitializedNamePtrList"};
17930 static constexpr bool traverse{true};
17931 static constexpr auto mbr_ptr{&SgFunctionParameterList::p_args};
17932 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17933 using bind = Desc<SgFunctionParameterList, SgInitializedNamePtrList SgFunctionParameterList::*, &SgFunctionParameterList::p_args>;
17934};
17938 static constexpr char const * const name{"FunctionParameterList"};
17939 static constexpr unsigned long variant{441};
17940 static constexpr bool concrete{true};
17941 using subclasses_t = mp::List<>;
17943};
17944template <> struct node_from_variant_t<441> { using type = SgFunctionParameterList; };
17945
17946// Class: FunctionParameterRefExp
17947template <> struct describe_field_t<SgFunctionParameterRefExp,int,&SgFunctionParameterRefExp::p_parameter_number> {
17949 using field_type = int;
17950 static constexpr size_t position{0};
17951 static constexpr char const * const name{"parameter_number"};
17952 static constexpr char const * const typestr{"int"};
17953 static constexpr bool traverse{false};
17954 static constexpr auto mbr_ptr{&SgFunctionParameterRefExp::p_parameter_number};
17955 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17956 using bind = Desc<SgFunctionParameterRefExp, int SgFunctionParameterRefExp::*, &SgFunctionParameterRefExp::p_parameter_number>;
17957};
17958template <> struct describe_field_t<SgFunctionParameterRefExp,int,&SgFunctionParameterRefExp::p_parameter_levels_up> {
17960 using field_type = int;
17961 static constexpr size_t position{1};
17962 static constexpr char const * const name{"parameter_levels_up"};
17963 static constexpr char const * const typestr{"int"};
17964 static constexpr bool traverse{false};
17965 static constexpr auto mbr_ptr{&SgFunctionParameterRefExp::p_parameter_levels_up};
17966 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17967 using bind = Desc<SgFunctionParameterRefExp, int SgFunctionParameterRefExp::*, &SgFunctionParameterRefExp::p_parameter_levels_up>;
17968};
17969template <> struct describe_field_t<SgFunctionParameterRefExp,SgExpression*,&SgFunctionParameterRefExp::p_parameter_expression> {
17971 using field_type = SgExpression*;
17972 static constexpr size_t position{2};
17973 static constexpr char const * const name{"parameter_expression"};
17974 static constexpr char const * const typestr{"SgExpression*"};
17975 static constexpr bool traverse{true};
17976 static constexpr auto mbr_ptr{&SgFunctionParameterRefExp::p_parameter_expression};
17977 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17978 using bind = Desc<SgFunctionParameterRefExp, SgExpression* SgFunctionParameterRefExp::*, &SgFunctionParameterRefExp::p_parameter_expression>;
17979};
17980template <> struct describe_field_t<SgFunctionParameterRefExp,SgType*,&SgFunctionParameterRefExp::p_parameter_type> {
17982 using field_type = SgType*;
17983 static constexpr size_t position{3};
17984 static constexpr char const * const name{"parameter_type"};
17985 static constexpr char const * const typestr{"SgType*"};
17986 static constexpr bool traverse{false};
17987 static constexpr auto mbr_ptr{&SgFunctionParameterRefExp::p_parameter_type};
17988 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
17989 using bind = Desc<SgFunctionParameterRefExp, SgType* SgFunctionParameterRefExp::*, &SgFunctionParameterRefExp::p_parameter_type>;
17990};
18000template <> struct node_from_variant_t<442> { using type = SgFunctionParameterRefExp; };
18001
18002// Class: FunctionParameterTypeList
18003template <> struct describe_field_t<SgFunctionParameterTypeList,SgTypePtrList,&SgFunctionParameterTypeList::p_arguments> {
18005 using field_type = SgTypePtrList;
18006 static constexpr size_t position{0};
18007 static constexpr char const * const name{"arguments"};
18008 static constexpr char const * const typestr{"SgTypePtrList"};
18009 static constexpr bool traverse{false};
18010 static constexpr auto mbr_ptr{&SgFunctionParameterTypeList::p_arguments};
18011 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18012 using bind = Desc<SgFunctionParameterTypeList, SgTypePtrList SgFunctionParameterTypeList::*, &SgFunctionParameterTypeList::p_arguments>;
18013};
18016 using base = SgSupport;
18017 static constexpr char const * const name{"FunctionParameterTypeList"};
18018 static constexpr unsigned long variant{443};
18019 static constexpr bool concrete{true};
18020 using subclasses_t = mp::List<>;
18022};
18023template <> struct node_from_variant_t<443> { using type = SgFunctionParameterTypeList; };
18024
18025// Class: FunctionRefExp
18026template <> struct describe_field_t<SgFunctionRefExp,SgFunctionSymbol*,&SgFunctionRefExp::p_symbol_i> {
18027 using parent = SgFunctionRefExp;
18029 static constexpr size_t position{0};
18030 static constexpr char const * const name{"symbol_i"};
18031 static constexpr char const * const typestr{"SgFunctionSymbol*"};
18032 static constexpr bool traverse{false};
18033 static constexpr auto mbr_ptr{&SgFunctionRefExp::p_symbol_i};
18034 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18035 using bind = Desc<SgFunctionRefExp, SgFunctionSymbol* SgFunctionRefExp::*, &SgFunctionRefExp::p_symbol_i>;
18036};
18037template <> struct describe_field_t<SgFunctionRefExp,SgFunctionType*,&SgFunctionRefExp::p_function_type> {
18038 using parent = SgFunctionRefExp;
18039 using field_type = SgFunctionType*;
18040 static constexpr size_t position{1};
18041 static constexpr char const * const name{"function_type"};
18042 static constexpr char const * const typestr{"SgFunctionType*"};
18043 static constexpr bool traverse{false};
18044 static constexpr auto mbr_ptr{&SgFunctionRefExp::p_function_type};
18045 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18046 using bind = Desc<SgFunctionRefExp, SgFunctionType* SgFunctionRefExp::*, &SgFunctionRefExp::p_function_type>;
18047};
18048template <> struct describe_field_t<SgFunctionRefExp,SgExpression*,&SgFunctionRefExp::p_originalExpressionTree> {
18049 using parent = SgFunctionRefExp;
18050 using field_type = SgExpression*;
18051 static constexpr size_t position{2};
18052 static constexpr char const * const name{"originalExpressionTree"};
18053 static constexpr char const * const typestr{"SgExpression*"};
18054 static constexpr bool traverse{false};
18055 static constexpr auto mbr_ptr{&SgFunctionRefExp::p_originalExpressionTree};
18056 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18057 using bind = Desc<SgFunctionRefExp, SgExpression* SgFunctionRefExp::*, &SgFunctionRefExp::p_originalExpressionTree>;
18058};
18059template <> struct describe_field_t<SgFunctionRefExp,int,&SgFunctionRefExp::p_name_qualification_length> {
18060 using parent = SgFunctionRefExp;
18061 using field_type = int;
18062 static constexpr size_t position{3};
18063 static constexpr char const * const name{"name_qualification_length"};
18064 static constexpr char const * const typestr{"int"};
18065 static constexpr bool traverse{false};
18066 static constexpr auto mbr_ptr{&SgFunctionRefExp::p_name_qualification_length};
18067 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18068 using bind = Desc<SgFunctionRefExp, int SgFunctionRefExp::*, &SgFunctionRefExp::p_name_qualification_length>;
18069};
18070template <> struct describe_field_t<SgFunctionRefExp,bool,&SgFunctionRefExp::p_type_elaboration_required> {
18071 using parent = SgFunctionRefExp;
18072 using field_type = bool;
18073 static constexpr size_t position{4};
18074 static constexpr char const * const name{"type_elaboration_required"};
18075 static constexpr char const * const typestr{"bool"};
18076 static constexpr bool traverse{false};
18077 static constexpr auto mbr_ptr{&SgFunctionRefExp::p_type_elaboration_required};
18078 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18079 using bind = Desc<SgFunctionRefExp, bool SgFunctionRefExp::*, &SgFunctionRefExp::p_type_elaboration_required>;
18080};
18081template <> struct describe_field_t<SgFunctionRefExp,bool,&SgFunctionRefExp::p_global_qualification_required> {
18082 using parent = SgFunctionRefExp;
18083 using field_type = bool;
18084 static constexpr size_t position{5};
18085 static constexpr char const * const name{"global_qualification_required"};
18086 static constexpr char const * const typestr{"bool"};
18087 static constexpr bool traverse{false};
18088 static constexpr auto mbr_ptr{&SgFunctionRefExp::p_global_qualification_required};
18089 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18090 using bind = Desc<SgFunctionRefExp, bool SgFunctionRefExp::*, &SgFunctionRefExp::p_global_qualification_required>;
18091};
18101template <> struct node_from_variant_t<444> { using type = SgFunctionRefExp; };
18102
18103// Class: FunctionSymbol
18104template <> struct describe_field_t<SgFunctionSymbol,SgFunctionDeclaration*,&SgFunctionSymbol::p_declaration> {
18105 using parent = SgFunctionSymbol;
18107 static constexpr size_t position{0};
18108 static constexpr char const * const name{"declaration"};
18109 static constexpr char const * const typestr{"SgFunctionDeclaration*"};
18110 static constexpr bool traverse{true};
18111 static constexpr auto mbr_ptr{&SgFunctionSymbol::p_declaration};
18112 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18113 using bind = Desc<SgFunctionSymbol, SgFunctionDeclaration* SgFunctionSymbol::*, &SgFunctionSymbol::p_declaration>;
18114};
18116 using node = SgFunctionSymbol;
18117 using base = SgSymbol;
18118 static constexpr char const * const name{"FunctionSymbol"};
18119 static constexpr unsigned long variant{445};
18120 static constexpr bool concrete{true};
18123};
18124template <> struct node_from_variant_t<445> { using type = SgFunctionSymbol; };
18125
18126// Class: FunctionType
18127template <> struct describe_field_t<SgFunctionType,SgType*,&SgFunctionType::p_return_type> {
18128 using parent = SgFunctionType;
18129 using field_type = SgType*;
18130 static constexpr size_t position{0};
18131 static constexpr char const * const name{"return_type"};
18132 static constexpr char const * const typestr{"SgType*"};
18133 static constexpr bool traverse{true};
18134 static constexpr auto mbr_ptr{&SgFunctionType::p_return_type};
18135 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18136 using bind = Desc<SgFunctionType, SgType* SgFunctionType::*, &SgFunctionType::p_return_type>;
18137};
18138template <> struct describe_field_t<SgFunctionType,bool,&SgFunctionType::p_has_ellipses> {
18139 using parent = SgFunctionType;
18140 using field_type = bool;
18141 static constexpr size_t position{1};
18142 static constexpr char const * const name{"has_ellipses"};
18143 static constexpr char const * const typestr{"bool"};
18144 static constexpr bool traverse{false};
18145 static constexpr auto mbr_ptr{&SgFunctionType::p_has_ellipses};
18146 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18147 using bind = Desc<SgFunctionType, bool SgFunctionType::*, &SgFunctionType::p_has_ellipses>;
18148};
18149template <> struct describe_field_t<SgFunctionType,SgType*,&SgFunctionType::p_orig_return_type> {
18150 using parent = SgFunctionType;
18151 using field_type = SgType*;
18152 static constexpr size_t position{2};
18153 static constexpr char const * const name{"orig_return_type"};
18154 static constexpr char const * const typestr{"SgType*"};
18155 static constexpr bool traverse{true};
18156 static constexpr auto mbr_ptr{&SgFunctionType::p_orig_return_type};
18157 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18158 using bind = Desc<SgFunctionType, SgType* SgFunctionType::*, &SgFunctionType::p_orig_return_type>;
18159};
18160template <> struct describe_field_t<SgFunctionType,SgFunctionParameterTypeList*,&SgFunctionType::p_argument_list> {
18161 using parent = SgFunctionType;
18163 static constexpr size_t position{3};
18164 static constexpr char const * const name{"argument_list"};
18165 static constexpr char const * const typestr{"SgFunctionParameterTypeList*"};
18166 static constexpr bool traverse{false};
18167 static constexpr auto mbr_ptr{&SgFunctionType::p_argument_list};
18168 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18169 using bind = Desc<SgFunctionType, SgFunctionParameterTypeList* SgFunctionType::*, &SgFunctionType::p_argument_list>;
18170};
18180template <> struct node_from_variant_t<446> { using type = SgFunctionType; };
18181
18182// Class: FunctionTypeSymbol
18183template <> struct describe_field_t<SgFunctionTypeSymbol,SgName,&SgFunctionTypeSymbol::p_name> {
18185 using field_type = SgName;
18186 static constexpr size_t position{0};
18187 static constexpr char const * const name{"name"};
18188 static constexpr char const * const typestr{"SgName"};
18189 static constexpr bool traverse{false};
18190 static constexpr auto mbr_ptr{&SgFunctionTypeSymbol::p_name};
18191 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18192 using bind = Desc<SgFunctionTypeSymbol, SgName SgFunctionTypeSymbol::*, &SgFunctionTypeSymbol::p_name>;
18193};
18194template <> struct describe_field_t<SgFunctionTypeSymbol,SgType*,&SgFunctionTypeSymbol::p_type> {
18196 using field_type = SgType*;
18197 static constexpr size_t position{1};
18198 static constexpr char const * const name{"type"};
18199 static constexpr char const * const typestr{"SgType*"};
18200 static constexpr bool traverse{false};
18201 static constexpr auto mbr_ptr{&SgFunctionTypeSymbol::p_type};
18202 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18203 using bind = Desc<SgFunctionTypeSymbol, SgType* SgFunctionTypeSymbol::*, &SgFunctionTypeSymbol::p_type>;
18204};
18206 using node = SgFunctionTypeSymbol;
18207 using base = SgSymbol;
18208 static constexpr char const * const name{"FunctionTypeSymbol"};
18209 static constexpr unsigned long variant{447};
18210 static constexpr bool concrete{true};
18211 using subclasses_t = mp::List<>;
18213};
18214template <> struct node_from_variant_t<447> { using type = SgFunctionTypeSymbol; };
18215
18216// Class: FunctionTypeTable
18219 using field_type = SgSymbolTable*;
18220 static constexpr size_t position{0};
18221 static constexpr char const * const name{"function_type_table"};
18222 static constexpr char const * const typestr{"SgSymbolTable*"};
18223 static constexpr bool traverse{false};
18224 static constexpr auto mbr_ptr{&SgFunctionTypeTable::p_function_type_table};
18225 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18226 using bind = Desc<SgFunctionTypeTable, SgSymbolTable* SgFunctionTypeTable::*, &SgFunctionTypeTable::p_function_type_table>;
18227};
18229 using node = SgFunctionTypeTable;
18230 using base = SgStatement;
18231 static constexpr char const * const name{"FunctionTypeTable"};
18232 static constexpr unsigned long variant{448};
18233 static constexpr bool concrete{true};
18234 using subclasses_t = mp::List<>;
18236};
18237template <> struct node_from_variant_t<448> { using type = SgFunctionTypeTable; };
18238
18239// Class: TypeTable
18240template <> struct describe_field_t<SgTypeTable,SgSymbolTable*,&SgTypeTable::p_type_table> {
18241 using parent = SgTypeTable;
18242 using field_type = SgSymbolTable*;
18243 static constexpr size_t position{0};
18244 static constexpr char const * const name{"type_table"};
18245 static constexpr char const * const typestr{"SgSymbolTable*"};
18246 static constexpr bool traverse{false};
18247 static constexpr auto mbr_ptr{&SgTypeTable::p_type_table};
18248 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18249 using bind = Desc<SgTypeTable, SgSymbolTable* SgTypeTable::*, &SgTypeTable::p_type_table>;
18250};
18251template <> struct describe_node_t<SgTypeTable> {
18252 using node = SgTypeTable;
18253 using base = SgSupport;
18254 static constexpr char const * const name{"TypeTable"};
18255 static constexpr unsigned long variant{449};
18256 static constexpr bool concrete{true};
18257 using subclasses_t = mp::List<>;
18259};
18260template <> struct node_from_variant_t<449> { using type = SgTypeTable; };
18261
18262// Class: Global
18263template <> struct describe_field_t<SgGlobal,SgDeclarationStatementPtrList,&SgGlobal::p_declarations> {
18264 using parent = SgGlobal;
18265 using field_type = SgDeclarationStatementPtrList;
18266 static constexpr size_t position{0};
18267 static constexpr char const * const name{"declarations"};
18268 static constexpr char const * const typestr{"SgDeclarationStatementPtrList"};
18269 static constexpr bool traverse{true};
18270 static constexpr auto mbr_ptr{&SgGlobal::p_declarations};
18271 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18272 using bind = Desc<SgGlobal, SgDeclarationStatementPtrList SgGlobal::*, &SgGlobal::p_declarations>;
18273};
18274template <> struct describe_node_t<SgGlobal> {
18275 using node = SgGlobal;
18276 using base = SgScopeStatement;
18277 static constexpr char const * const name{"Global"};
18278 static constexpr unsigned long variant{450};
18279 static constexpr bool concrete{true};
18280 using subclasses_t = mp::List<>;
18282};
18283template <> struct node_from_variant_t<450> { using type = SgGlobal; };
18284
18285// Class: GotoStatement
18287 using parent = SgGotoStatement;
18289 static constexpr size_t position{0};
18290 static constexpr char const * const name{"label"};
18291 static constexpr char const * const typestr{"SgLabelStatement*"};
18292 static constexpr bool traverse{false};
18293 static constexpr auto mbr_ptr{&SgGotoStatement::p_label};
18294 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18295 using bind = Desc<SgGotoStatement, SgLabelStatement* SgGotoStatement::*, &SgGotoStatement::p_label>;
18296};
18297template <> struct describe_field_t<SgGotoStatement,SgLabelRefExp*,&SgGotoStatement::p_label_expression> {
18298 using parent = SgGotoStatement;
18299 using field_type = SgLabelRefExp*;
18300 static constexpr size_t position{1};
18301 static constexpr char const * const name{"label_expression"};
18302 static constexpr char const * const typestr{"SgLabelRefExp*"};
18303 static constexpr bool traverse{false};
18304 static constexpr auto mbr_ptr{&SgGotoStatement::p_label_expression};
18305 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18306 using bind = Desc<SgGotoStatement, SgLabelRefExp* SgGotoStatement::*, &SgGotoStatement::p_label_expression>;
18307};
18308template <> struct describe_field_t<SgGotoStatement,SgExpression*,&SgGotoStatement::p_selector_expression> {
18309 using parent = SgGotoStatement;
18310 using field_type = SgExpression*;
18311 static constexpr size_t position{2};
18312 static constexpr char const * const name{"selector_expression"};
18313 static constexpr char const * const typestr{"SgExpression*"};
18314 static constexpr bool traverse{false};
18315 static constexpr auto mbr_ptr{&SgGotoStatement::p_selector_expression};
18316 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18317 using bind = Desc<SgGotoStatement, SgExpression* SgGotoStatement::*, &SgGotoStatement::p_selector_expression>;
18318};
18320 using node = SgGotoStatement;
18321 using base = SgStatement;
18322 static constexpr char const * const name{"GotoStatement"};
18323 static constexpr unsigned long variant{451};
18324 static constexpr bool concrete{true};
18325 using subclasses_t = mp::List<>;
18327};
18328template <> struct node_from_variant_t<451> { using type = SgGotoStatement; };
18329
18330// Class: Graph
18331template <> struct describe_field_t<SgGraph,std::string,&SgGraph::p_name> {
18332 using parent = SgGraph;
18333 using field_type = std::string;
18334 static constexpr size_t position{0};
18335 static constexpr char const * const name{"name"};
18336 static constexpr char const * const typestr{"std::string"};
18337 static constexpr bool traverse{false};
18338 static constexpr auto mbr_ptr{&SgGraph::p_name};
18339 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18340 using bind = Desc<SgGraph, std::string SgGraph::*, &SgGraph::p_name>;
18341};
18342template <> struct describe_field_t<SgGraph,rose_graph_integer_node_hash_map,&SgGraph::p_node_index_to_node_map> {
18343 using parent = SgGraph;
18345 static constexpr size_t position{1};
18346 static constexpr char const * const name{"node_index_to_node_map"};
18347 static constexpr char const * const typestr{"rose_graph_integer_node_hash_map"};
18348 static constexpr bool traverse{false};
18349 static constexpr auto mbr_ptr{&SgGraph::p_node_index_to_node_map};
18350 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18351 using bind = Desc<SgGraph, rose_graph_integer_node_hash_map SgGraph::*, &SgGraph::p_node_index_to_node_map>;
18352};
18353template <> struct describe_field_t<SgGraph,rose_graph_integer_edge_hash_map,&SgGraph::p_edge_index_to_edge_map> {
18354 using parent = SgGraph;
18356 static constexpr size_t position{2};
18357 static constexpr char const * const name{"edge_index_to_edge_map"};
18358 static constexpr char const * const typestr{"rose_graph_integer_edge_hash_map"};
18359 static constexpr bool traverse{false};
18360 static constexpr auto mbr_ptr{&SgGraph::p_edge_index_to_edge_map};
18361 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18362 using bind = Desc<SgGraph, rose_graph_integer_edge_hash_map SgGraph::*, &SgGraph::p_edge_index_to_edge_map>;
18363};
18364template <> struct describe_field_t<SgGraph,rose_graph_integerpair_edge_hash_multimap,&SgGraph::p_node_index_pair_to_edge_multimap> {
18365 using parent = SgGraph;
18367 static constexpr size_t position{3};
18368 static constexpr char const * const name{"node_index_pair_to_edge_multimap"};
18369 static constexpr char const * const typestr{"rose_graph_integerpair_edge_hash_multimap"};
18370 static constexpr bool traverse{false};
18371 static constexpr auto mbr_ptr{&SgGraph::p_node_index_pair_to_edge_multimap};
18372 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18373 using bind = Desc<SgGraph, rose_graph_integerpair_edge_hash_multimap SgGraph::*, &SgGraph::p_node_index_pair_to_edge_multimap>;
18374};
18375template <> struct describe_field_t<SgGraph,rose_graph_string_integer_hash_multimap,&SgGraph::p_string_to_node_index_multimap> {
18376 using parent = SgGraph;
18378 static constexpr size_t position{4};
18379 static constexpr char const * const name{"string_to_node_index_multimap"};
18380 static constexpr char const * const typestr{"rose_graph_string_integer_hash_multimap"};
18381 static constexpr bool traverse{false};
18382 static constexpr auto mbr_ptr{&SgGraph::p_string_to_node_index_multimap};
18383 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18384 using bind = Desc<SgGraph, rose_graph_string_integer_hash_multimap SgGraph::*, &SgGraph::p_string_to_node_index_multimap>;
18385};
18386template <> struct describe_field_t<SgGraph,rose_graph_string_integer_hash_multimap,&SgGraph::p_string_to_edge_index_multimap> {
18387 using parent = SgGraph;
18389 static constexpr size_t position{5};
18390 static constexpr char const * const name{"string_to_edge_index_multimap"};
18391 static constexpr char const * const typestr{"rose_graph_string_integer_hash_multimap"};
18392 static constexpr bool traverse{false};
18393 static constexpr auto mbr_ptr{&SgGraph::p_string_to_edge_index_multimap};
18394 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18395 using bind = Desc<SgGraph, rose_graph_string_integer_hash_multimap SgGraph::*, &SgGraph::p_string_to_edge_index_multimap>;
18396};
18397template <> struct describe_field_t<SgGraph,rose_graph_integer_edge_hash_multimap,&SgGraph::p_node_index_to_edge_multimap> {
18398 using parent = SgGraph;
18400 static constexpr size_t position{6};
18401 static constexpr char const * const name{"node_index_to_edge_multimap"};
18402 static constexpr char const * const typestr{"rose_graph_integer_edge_hash_multimap"};
18403 static constexpr bool traverse{false};
18404 static constexpr auto mbr_ptr{&SgGraph::p_node_index_to_edge_multimap};
18405 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18406 using bind = Desc<SgGraph, rose_graph_integer_edge_hash_multimap SgGraph::*, &SgGraph::p_node_index_to_edge_multimap>;
18407};
18408template <> struct describe_field_t<SgGraph,int,&SgGraph::p_index> {
18409 using parent = SgGraph;
18410 using field_type = int;
18411 static constexpr size_t position{7};
18412 static constexpr char const * const name{"index"};
18413 static constexpr char const * const typestr{"int"};
18414 static constexpr bool traverse{false};
18415 static constexpr auto mbr_ptr{&SgGraph::p_index};
18416 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18417 using bind = Desc<SgGraph, int SgGraph::*, &SgGraph::p_index>;
18418};
18419template <> struct describe_field_t<SgGraph,SgBoostEdgeList,&SgGraph::p_boost_edges> {
18420 using parent = SgGraph;
18421 using field_type = SgBoostEdgeList;
18422 static constexpr size_t position{8};
18423 static constexpr char const * const name{"boost_edges"};
18424 static constexpr char const * const typestr{"SgBoostEdgeList"};
18425 static constexpr bool traverse{false};
18426 static constexpr auto mbr_ptr{&SgGraph::p_boost_edges};
18427 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18428 using bind = Desc<SgGraph, SgBoostEdgeList SgGraph::*, &SgGraph::p_boost_edges>;
18429};
18430template <> struct describe_field_t<SgGraph,SgBoostEdgeWeightList,&SgGraph::p_boost_edge_weights> {
18431 using parent = SgGraph;
18432 using field_type = SgBoostEdgeWeightList;
18433 static constexpr size_t position{9};
18434 static constexpr char const * const name{"boost_edge_weights"};
18435 static constexpr char const * const typestr{"SgBoostEdgeWeightList"};
18436 static constexpr bool traverse{false};
18437 static constexpr auto mbr_ptr{&SgGraph::p_boost_edge_weights};
18438 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18439 using bind = Desc<SgGraph, SgBoostEdgeWeightList SgGraph::*, &SgGraph::p_boost_edge_weights>;
18440};
18441template <> struct describe_field_t<SgGraph,AstAttributeMechanism*,&SgGraph::p_attributeMechanism> {
18442 using parent = SgGraph;
18444 static constexpr size_t position{10};
18445 static constexpr char const * const name{"attributeMechanism"};
18446 static constexpr char const * const typestr{"AstAttributeMechanism*"};
18447 static constexpr bool traverse{false};
18448 static constexpr auto mbr_ptr{&SgGraph::p_attributeMechanism};
18449 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18450 using bind = Desc<SgGraph, AstAttributeMechanism* SgGraph::*, &SgGraph::p_attributeMechanism>;
18451};
18452template <> struct describe_field_t<SgGraph,std::map<int, std::string>,&SgGraph::p_properties> {
18453 using parent = SgGraph;
18454 using field_type = std::map<int, std::string>;
18455 static constexpr size_t position{11};
18456 static constexpr char const * const name{"properties"};
18457 static constexpr char const * const typestr{"std::map<int, std::string>"};
18458 static constexpr bool traverse{false};
18459 static constexpr auto mbr_ptr{&SgGraph::p_properties};
18460 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18461 using bind = Desc<SgGraph, std::map<int, std::string> SgGraph::*, &SgGraph::p_properties>;
18462};
18472template <> struct node_from_variant_t<452> { using type = SgGraph; };
18473
18474// Class: GraphEdge
18475template <> struct describe_field_t<SgGraphEdge,SgGraphNode*,&SgGraphEdge::p_node_A> {
18476 using parent = SgGraphEdge;
18477 using field_type = SgGraphNode*;
18478 static constexpr size_t position{0};
18479 static constexpr char const * const name{"node_A"};
18480 static constexpr char const * const typestr{"SgGraphNode*"};
18481 static constexpr bool traverse{false};
18482 static constexpr auto mbr_ptr{&SgGraphEdge::p_node_A};
18483 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18484 using bind = Desc<SgGraphEdge, SgGraphNode* SgGraphEdge::*, &SgGraphEdge::p_node_A>;
18485};
18486template <> struct describe_field_t<SgGraphEdge,SgGraphNode*,&SgGraphEdge::p_node_B> {
18487 using parent = SgGraphEdge;
18488 using field_type = SgGraphNode*;
18489 static constexpr size_t position{1};
18490 static constexpr char const * const name{"node_B"};
18491 static constexpr char const * const typestr{"SgGraphNode*"};
18492 static constexpr bool traverse{false};
18493 static constexpr auto mbr_ptr{&SgGraphEdge::p_node_B};
18494 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18495 using bind = Desc<SgGraphEdge, SgGraphNode* SgGraphEdge::*, &SgGraphEdge::p_node_B>;
18496};
18497template <> struct describe_field_t<SgGraphEdge,std::string,&SgGraphEdge::p_name> {
18498 using parent = SgGraphEdge;
18499 using field_type = std::string;
18500 static constexpr size_t position{2};
18501 static constexpr char const * const name{"name"};
18502 static constexpr char const * const typestr{"std::string"};
18503 static constexpr bool traverse{false};
18504 static constexpr auto mbr_ptr{&SgGraphEdge::p_name};
18505 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18506 using bind = Desc<SgGraphEdge, std::string SgGraphEdge::*, &SgGraphEdge::p_name>;
18507};
18508template <> struct describe_field_t<SgGraphEdge,int,&SgGraphEdge::p_index> {
18509 using parent = SgGraphEdge;
18510 using field_type = int;
18511 static constexpr size_t position{3};
18512 static constexpr char const * const name{"index"};
18513 static constexpr char const * const typestr{"int"};
18514 static constexpr bool traverse{false};
18515 static constexpr auto mbr_ptr{&SgGraphEdge::p_index};
18516 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18517 using bind = Desc<SgGraphEdge, int SgGraphEdge::*, &SgGraphEdge::p_index>;
18518};
18519template <> struct describe_field_t<SgGraphEdge,AstAttributeMechanism*,&SgGraphEdge::p_attributeMechanism> {
18520 using parent = SgGraphEdge;
18522 static constexpr size_t position{4};
18523 static constexpr char const * const name{"attributeMechanism"};
18524 static constexpr char const * const typestr{"AstAttributeMechanism*"};
18525 static constexpr bool traverse{false};
18526 static constexpr auto mbr_ptr{&SgGraphEdge::p_attributeMechanism};
18527 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18528 using bind = Desc<SgGraphEdge, AstAttributeMechanism* SgGraphEdge::*, &SgGraphEdge::p_attributeMechanism>;
18529};
18530template <> struct describe_field_t<SgGraphEdge,std::map<int, std::string>,&SgGraphEdge::p_properties> {
18531 using parent = SgGraphEdge;
18532 using field_type = std::map<int, std::string>;
18533 static constexpr size_t position{5};
18534 static constexpr char const * const name{"properties"};
18535 static constexpr char const * const typestr{"std::map<int, std::string>"};
18536 static constexpr bool traverse{false};
18537 static constexpr auto mbr_ptr{&SgGraphEdge::p_properties};
18538 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18539 using bind = Desc<SgGraphEdge, std::map<int, std::string> SgGraphEdge::*, &SgGraphEdge::p_properties>;
18540};
18550template <> struct node_from_variant_t<453> { using type = SgGraphEdge; };
18551
18552// Class: GraphEdgeList
18554 using node = SgGraphEdgeList;
18555 using base = SgSupport;
18556 static constexpr char const * const name{"GraphEdgeList"};
18557 static constexpr unsigned long variant{454};
18558 static constexpr bool concrete{true};
18559 using subclasses_t = mp::List<>;
18560 using fields_t = mp::List<>;
18561};
18562template <> struct node_from_variant_t<454> { using type = SgGraphEdgeList; };
18563
18564// Class: GraphNode
18565template <> struct describe_field_t<SgGraphNode,std::string,&SgGraphNode::p_name> {
18566 using parent = SgGraphNode;
18567 using field_type = std::string;
18568 static constexpr size_t position{0};
18569 static constexpr char const * const name{"name"};
18570 static constexpr char const * const typestr{"std::string"};
18571 static constexpr bool traverse{false};
18572 static constexpr auto mbr_ptr{&SgGraphNode::p_name};
18573 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18574 using bind = Desc<SgGraphNode, std::string SgGraphNode::*, &SgGraphNode::p_name>;
18575};
18576template <> struct describe_field_t<SgGraphNode,SgNode*,&SgGraphNode::p_SgNode> {
18577 using parent = SgGraphNode;
18578 using field_type = SgNode*;
18579 static constexpr size_t position{1};
18580 static constexpr char const * const name{"SgNode"};
18581 static constexpr char const * const typestr{"SgNode*"};
18582 static constexpr bool traverse{false};
18583 static constexpr auto mbr_ptr{&SgGraphNode::p_SgNode};
18584 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18585 using bind = Desc<SgGraphNode, SgNode* SgGraphNode::*, &SgGraphNode::p_SgNode>;
18586};
18587template <> struct describe_field_t<SgGraphNode,int,&SgGraphNode::p_index> {
18588 using parent = SgGraphNode;
18589 using field_type = int;
18590 static constexpr size_t position{2};
18591 static constexpr char const * const name{"index"};
18592 static constexpr char const * const typestr{"int"};
18593 static constexpr bool traverse{false};
18594 static constexpr auto mbr_ptr{&SgGraphNode::p_index};
18595 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18596 using bind = Desc<SgGraphNode, int SgGraphNode::*, &SgGraphNode::p_index>;
18597};
18598template <> struct describe_field_t<SgGraphNode,AstAttributeMechanism*,&SgGraphNode::p_attributeMechanism> {
18599 using parent = SgGraphNode;
18601 static constexpr size_t position{3};
18602 static constexpr char const * const name{"attributeMechanism"};
18603 static constexpr char const * const typestr{"AstAttributeMechanism*"};
18604 static constexpr bool traverse{false};
18605 static constexpr auto mbr_ptr{&SgGraphNode::p_attributeMechanism};
18606 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18607 using bind = Desc<SgGraphNode, AstAttributeMechanism* SgGraphNode::*, &SgGraphNode::p_attributeMechanism>;
18608};
18609template <> struct describe_field_t<SgGraphNode,std::map<int, std::string>,&SgGraphNode::p_properties> {
18610 using parent = SgGraphNode;
18611 using field_type = std::map<int, std::string>;
18612 static constexpr size_t position{4};
18613 static constexpr char const * const name{"properties"};
18614 static constexpr char const * const typestr{"std::map<int, std::string>"};
18615 static constexpr bool traverse{false};
18616 static constexpr auto mbr_ptr{&SgGraphNode::p_properties};
18617 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18618 using bind = Desc<SgGraphNode, std::map<int, std::string> SgGraphNode::*, &SgGraphNode::p_properties>;
18619};
18620template <> struct describe_node_t<SgGraphNode> {
18621 using node = SgGraphNode;
18622 using base = SgSupport;
18623 static constexpr char const * const name{"GraphNode"};
18624 static constexpr unsigned long variant{455};
18625 static constexpr bool concrete{true};
18626 using subclasses_t = mp::List<>;
18628};
18629template <> struct node_from_variant_t<455> { using type = SgGraphNode; };
18630
18631// Class: GraphNodeList
18633 using node = SgGraphNodeList;
18634 using base = SgSupport;
18635 static constexpr char const * const name{"GraphNodeList"};
18636 static constexpr unsigned long variant{456};
18637 static constexpr bool concrete{true};
18638 using subclasses_t = mp::List<>;
18639 using fields_t = mp::List<>;
18640};
18641template <> struct node_from_variant_t<456> { using type = SgGraphNodeList; };
18642
18643// Class: GreaterOrEqualOp
18645 using node = SgGreaterOrEqualOp;
18646 using base = SgBinaryOp;
18647 static constexpr char const * const name{"GreaterOrEqualOp"};
18648 static constexpr unsigned long variant{457};
18649 static constexpr bool concrete{true};
18650 using subclasses_t = mp::List<>;
18651 using fields_t = mp::List<>;
18652};
18653template <> struct node_from_variant_t<457> { using type = SgGreaterOrEqualOp; };
18654
18655// Class: GreaterThanOp
18657 using node = SgGreaterThanOp;
18658 using base = SgBinaryOp;
18659 static constexpr char const * const name{"GreaterThanOp"};
18660 static constexpr unsigned long variant{458};
18661 static constexpr bool concrete{true};
18662 using subclasses_t = mp::List<>;
18663 using fields_t = mp::List<>;
18664};
18665template <> struct node_from_variant_t<458> { using type = SgGreaterThanOp; };
18666
18667// Class: IOItemExpression
18668template <> struct describe_field_t<SgIOItemExpression,SgName,&SgIOItemExpression::p_name> {
18669 using parent = SgIOItemExpression;
18670 using field_type = SgName;
18671 static constexpr size_t position{0};
18672 static constexpr char const * const name{"name"};
18673 static constexpr char const * const typestr{"SgName"};
18674 static constexpr bool traverse{false};
18675 static constexpr auto mbr_ptr{&SgIOItemExpression::p_name};
18676 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18677 using bind = Desc<SgIOItemExpression, SgName SgIOItemExpression::*, &SgIOItemExpression::p_name>;
18678};
18679template <> struct describe_field_t<SgIOItemExpression,SgExpression*,&SgIOItemExpression::p_io_item> {
18680 using parent = SgIOItemExpression;
18681 using field_type = SgExpression*;
18682 static constexpr size_t position{1};
18683 static constexpr char const * const name{"io_item"};
18684 static constexpr char const * const typestr{"SgExpression*"};
18685 static constexpr bool traverse{true};
18686 static constexpr auto mbr_ptr{&SgIOItemExpression::p_io_item};
18687 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18688 using bind = Desc<SgIOItemExpression, SgExpression* SgIOItemExpression::*, &SgIOItemExpression::p_io_item>;
18689};
18691 using node = SgIOItemExpression;
18692 using base = SgExpression;
18693 static constexpr char const * const name{"IOItemExpression"};
18694 static constexpr unsigned long variant{459};
18695 static constexpr bool concrete{true};
18696 using subclasses_t = mp::List<>;
18698};
18699template <> struct node_from_variant_t<459> { using type = SgIOItemExpression; };
18700
18701// Class: IOStatement
18702template <> struct describe_field_t<SgIOStatement,SgIOStatement::io_statement_enum,&SgIOStatement::p_io_statement> {
18703 using parent = SgIOStatement;
18705 static constexpr size_t position{0};
18706 static constexpr char const * const name{"io_statement"};
18707 static constexpr char const * const typestr{"SgIOStatement::io_statement_enum"};
18708 static constexpr bool traverse{false};
18709 static constexpr auto mbr_ptr{&SgIOStatement::p_io_statement};
18710 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18711 using bind = Desc<SgIOStatement, SgIOStatement::io_statement_enum SgIOStatement::*, &SgIOStatement::p_io_statement>;
18712};
18713template <> struct describe_field_t<SgIOStatement,SgExprListExp*,&SgIOStatement::p_io_stmt_list> {
18714 using parent = SgIOStatement;
18715 using field_type = SgExprListExp*;
18716 static constexpr size_t position{1};
18717 static constexpr char const * const name{"io_stmt_list"};
18718 static constexpr char const * const typestr{"SgExprListExp*"};
18719 static constexpr bool traverse{true};
18720 static constexpr auto mbr_ptr{&SgIOStatement::p_io_stmt_list};
18721 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18722 using bind = Desc<SgIOStatement, SgExprListExp* SgIOStatement::*, &SgIOStatement::p_io_stmt_list>;
18723};
18724template <> struct describe_field_t<SgIOStatement,SgExpression*,&SgIOStatement::p_unit> {
18725 using parent = SgIOStatement;
18726 using field_type = SgExpression*;
18727 static constexpr size_t position{2};
18728 static constexpr char const * const name{"unit"};
18729 static constexpr char const * const typestr{"SgExpression*"};
18730 static constexpr bool traverse{true};
18731 static constexpr auto mbr_ptr{&SgIOStatement::p_unit};
18732 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18733 using bind = Desc<SgIOStatement, SgExpression* SgIOStatement::*, &SgIOStatement::p_unit>;
18734};
18735template <> struct describe_field_t<SgIOStatement,SgExpression*,&SgIOStatement::p_iostat> {
18736 using parent = SgIOStatement;
18737 using field_type = SgExpression*;
18738 static constexpr size_t position{3};
18739 static constexpr char const * const name{"iostat"};
18740 static constexpr char const * const typestr{"SgExpression*"};
18741 static constexpr bool traverse{true};
18742 static constexpr auto mbr_ptr{&SgIOStatement::p_iostat};
18743 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18744 using bind = Desc<SgIOStatement, SgExpression* SgIOStatement::*, &SgIOStatement::p_iostat>;
18745};
18746template <> struct describe_field_t<SgIOStatement,SgExpression*,&SgIOStatement::p_err> {
18747 using parent = SgIOStatement;
18748 using field_type = SgExpression*;
18749 static constexpr size_t position{4};
18750 static constexpr char const * const name{"err"};
18751 static constexpr char const * const typestr{"SgExpression*"};
18752 static constexpr bool traverse{true};
18753 static constexpr auto mbr_ptr{&SgIOStatement::p_err};
18754 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18755 using bind = Desc<SgIOStatement, SgExpression* SgIOStatement::*, &SgIOStatement::p_err>;
18756};
18757template <> struct describe_field_t<SgIOStatement,SgExpression*,&SgIOStatement::p_iomsg> {
18758 using parent = SgIOStatement;
18759 using field_type = SgExpression*;
18760 static constexpr size_t position{5};
18761 static constexpr char const * const name{"iomsg"};
18762 static constexpr char const * const typestr{"SgExpression*"};
18763 static constexpr bool traverse{true};
18764 static constexpr auto mbr_ptr{&SgIOStatement::p_iomsg};
18765 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18766 using bind = Desc<SgIOStatement, SgExpression* SgIOStatement::*, &SgIOStatement::p_iomsg>;
18767};
18777template <> struct node_from_variant_t<460> { using type = SgIOStatement; };
18778
18779// Class: IdentDirectiveStatement
18783 static constexpr char const * const name{"IdentDirectiveStatement"};
18784 static constexpr unsigned long variant{461};
18785 static constexpr bool concrete{true};
18786 using subclasses_t = mp::List<>;
18787 using fields_t = mp::List<>;
18788};
18789template <> struct node_from_variant_t<461> { using type = SgIdentDirectiveStatement; };
18790
18791// Class: IfDirectiveStatement
18795 static constexpr char const * const name{"IfDirectiveStatement"};
18796 static constexpr unsigned long variant{462};
18797 static constexpr bool concrete{true};
18798 using subclasses_t = mp::List<>;
18799 using fields_t = mp::List<>;
18800};
18801template <> struct node_from_variant_t<462> { using type = SgIfDirectiveStatement; };
18802
18803// Class: IfStmt
18805 using parent = SgIfStmt;
18806 using field_type = SgStatement*;
18807 static constexpr size_t position{0};
18808 static constexpr char const * const name{"conditional"};
18809 static constexpr char const * const typestr{"SgStatement*"};
18810 static constexpr bool traverse{true};
18811 static constexpr auto mbr_ptr{&SgIfStmt::p_conditional};
18812 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18813 using bind = Desc<SgIfStmt, SgStatement* SgIfStmt::*, &SgIfStmt::p_conditional>;
18814};
18816 using parent = SgIfStmt;
18817 using field_type = SgStatement*;
18818 static constexpr size_t position{1};
18819 static constexpr char const * const name{"true_body"};
18820 static constexpr char const * const typestr{"SgStatement*"};
18821 static constexpr bool traverse{true};
18822 static constexpr auto mbr_ptr{&SgIfStmt::p_true_body};
18823 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18824 using bind = Desc<SgIfStmt, SgStatement* SgIfStmt::*, &SgIfStmt::p_true_body>;
18825};
18827 using parent = SgIfStmt;
18828 using field_type = SgStatement*;
18829 static constexpr size_t position{2};
18830 static constexpr char const * const name{"false_body"};
18831 static constexpr char const * const typestr{"SgStatement*"};
18832 static constexpr bool traverse{true};
18833 static constexpr auto mbr_ptr{&SgIfStmt::p_false_body};
18834 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18835 using bind = Desc<SgIfStmt, SgStatement* SgIfStmt::*, &SgIfStmt::p_false_body>;
18836};
18837template <> struct describe_field_t<SgIfStmt,bool,&SgIfStmt::p_is_if_constexpr_statement> {
18838 using parent = SgIfStmt;
18839 using field_type = bool;
18840 static constexpr size_t position{3};
18841 static constexpr char const * const name{"is_if_constexpr_statement"};
18842 static constexpr char const * const typestr{"bool"};
18843 static constexpr bool traverse{false};
18844 static constexpr auto mbr_ptr{&SgIfStmt::p_is_if_constexpr_statement};
18845 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18846 using bind = Desc<SgIfStmt, bool SgIfStmt::*, &SgIfStmt::p_is_if_constexpr_statement>;
18847};
18848template <> struct describe_field_t<SgIfStmt,bool,&SgIfStmt::p_if_constexpr_value_known> {
18849 using parent = SgIfStmt;
18850 using field_type = bool;
18851 static constexpr size_t position{4};
18852 static constexpr char const * const name{"if_constexpr_value_known"};
18853 static constexpr char const * const typestr{"bool"};
18854 static constexpr bool traverse{false};
18855 static constexpr auto mbr_ptr{&SgIfStmt::p_if_constexpr_value_known};
18856 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18857 using bind = Desc<SgIfStmt, bool SgIfStmt::*, &SgIfStmt::p_if_constexpr_value_known>;
18858};
18859template <> struct describe_field_t<SgIfStmt,bool,&SgIfStmt::p_if_constexpr_value> {
18860 using parent = SgIfStmt;
18861 using field_type = bool;
18862 static constexpr size_t position{5};
18863 static constexpr char const * const name{"if_constexpr_value"};
18864 static constexpr char const * const typestr{"bool"};
18865 static constexpr bool traverse{false};
18866 static constexpr auto mbr_ptr{&SgIfStmt::p_if_constexpr_value};
18867 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18868 using bind = Desc<SgIfStmt, bool SgIfStmt::*, &SgIfStmt::p_if_constexpr_value>;
18869};
18870template <> struct describe_field_t<SgIfStmt,SgLabelRefExp*,&SgIfStmt::p_else_numeric_label> {
18871 using parent = SgIfStmt;
18872 using field_type = SgLabelRefExp*;
18873 static constexpr size_t position{6};
18874 static constexpr char const * const name{"else_numeric_label"};
18875 static constexpr char const * const typestr{"SgLabelRefExp*"};
18876 static constexpr bool traverse{false};
18877 static constexpr auto mbr_ptr{&SgIfStmt::p_else_numeric_label};
18878 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18879 using bind = Desc<SgIfStmt, SgLabelRefExp* SgIfStmt::*, &SgIfStmt::p_else_numeric_label>;
18880};
18881template <> struct describe_field_t<SgIfStmt,std::string,&SgIfStmt::p_string_label> {
18882 using parent = SgIfStmt;
18883 using field_type = std::string;
18884 static constexpr size_t position{7};
18885 static constexpr char const * const name{"string_label"};
18886 static constexpr char const * const typestr{"std::string"};
18887 static constexpr bool traverse{false};
18888 static constexpr auto mbr_ptr{&SgIfStmt::p_string_label};
18889 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18890 using bind = Desc<SgIfStmt, std::string SgIfStmt::*, &SgIfStmt::p_string_label>;
18891};
18892template <> struct describe_field_t<SgIfStmt,SgLabelRefExp*,&SgIfStmt::p_end_numeric_label> {
18893 using parent = SgIfStmt;
18894 using field_type = SgLabelRefExp*;
18895 static constexpr size_t position{8};
18896 static constexpr char const * const name{"end_numeric_label"};
18897 static constexpr char const * const typestr{"SgLabelRefExp*"};
18898 static constexpr bool traverse{false};
18899 static constexpr auto mbr_ptr{&SgIfStmt::p_end_numeric_label};
18900 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18901 using bind = Desc<SgIfStmt, SgLabelRefExp* SgIfStmt::*, &SgIfStmt::p_end_numeric_label>;
18902};
18903template <> struct describe_field_t<SgIfStmt,bool,&SgIfStmt::p_has_end_statement> {
18904 using parent = SgIfStmt;
18905 using field_type = bool;
18906 static constexpr size_t position{9};
18907 static constexpr char const * const name{"has_end_statement"};
18908 static constexpr char const * const typestr{"bool"};
18909 static constexpr bool traverse{false};
18910 static constexpr auto mbr_ptr{&SgIfStmt::p_has_end_statement};
18911 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18912 using bind = Desc<SgIfStmt, bool SgIfStmt::*, &SgIfStmt::p_has_end_statement>;
18913};
18914template <> struct describe_field_t<SgIfStmt,bool,&SgIfStmt::p_use_then_keyword> {
18915 using parent = SgIfStmt;
18916 using field_type = bool;
18917 static constexpr size_t position{10};
18918 static constexpr char const * const name{"use_then_keyword"};
18919 static constexpr char const * const typestr{"bool"};
18920 static constexpr bool traverse{false};
18921 static constexpr auto mbr_ptr{&SgIfStmt::p_use_then_keyword};
18922 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18923 using bind = Desc<SgIfStmt, bool SgIfStmt::*, &SgIfStmt::p_use_then_keyword>;
18924};
18925template <> struct describe_field_t<SgIfStmt,bool,&SgIfStmt::p_is_else_if_statement> {
18926 using parent = SgIfStmt;
18927 using field_type = bool;
18928 static constexpr size_t position{11};
18929 static constexpr char const * const name{"is_else_if_statement"};
18930 static constexpr char const * const typestr{"bool"};
18931 static constexpr bool traverse{false};
18932 static constexpr auto mbr_ptr{&SgIfStmt::p_is_else_if_statement};
18933 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18934 using bind = Desc<SgIfStmt, bool SgIfStmt::*, &SgIfStmt::p_is_else_if_statement>;
18935};
18945template <> struct node_from_variant_t<463> { using type = SgIfStmt; };
18946
18947// Class: IfdefDirectiveStatement
18951 static constexpr char const * const name{"IfdefDirectiveStatement"};
18952 static constexpr unsigned long variant{464};
18953 static constexpr bool concrete{true};
18954 using subclasses_t = mp::List<>;
18955 using fields_t = mp::List<>;
18956};
18957template <> struct node_from_variant_t<464> { using type = SgIfdefDirectiveStatement; };
18958
18959// Class: IfndefDirectiveStatement
18963 static constexpr char const * const name{"IfndefDirectiveStatement"};
18964 static constexpr unsigned long variant{465};
18965 static constexpr bool concrete{true};
18966 using subclasses_t = mp::List<>;
18967 using fields_t = mp::List<>;
18968};
18969template <> struct node_from_variant_t<465> { using type = SgIfndefDirectiveStatement; };
18970
18971// Class: ImageControlStatement
18972template <> struct describe_field_t<SgImageControlStatement,SgImageControlStatement::image_control_statement_enum,&SgImageControlStatement::p_image_control_statement> {
18975 static constexpr size_t position{0};
18976 static constexpr char const * const name{"image_control_statement"};
18977 static constexpr char const * const typestr{"SgImageControlStatement::image_control_statement_enum"};
18978 static constexpr bool traverse{false};
18979 static constexpr auto mbr_ptr{&SgImageControlStatement::p_image_control_statement};
18980 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18981 using bind = Desc<SgImageControlStatement, SgImageControlStatement::image_control_statement_enum SgImageControlStatement::*, &SgImageControlStatement::p_image_control_statement>;
18982};
18983template <> struct describe_field_t<SgImageControlStatement,SgExpression*,&SgImageControlStatement::p_stat> {
18985 using field_type = SgExpression*;
18986 static constexpr size_t position{1};
18987 static constexpr char const * const name{"stat"};
18988 static constexpr char const * const typestr{"SgExpression*"};
18989 static constexpr bool traverse{true};
18990 static constexpr auto mbr_ptr{&SgImageControlStatement::p_stat};
18991 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
18992 using bind = Desc<SgImageControlStatement, SgExpression* SgImageControlStatement::*, &SgImageControlStatement::p_stat>;
18993};
18994template <> struct describe_field_t<SgImageControlStatement,SgExpression*,&SgImageControlStatement::p_err_msg> {
18996 using field_type = SgExpression*;
18997 static constexpr size_t position{2};
18998 static constexpr char const * const name{"err_msg"};
18999 static constexpr char const * const typestr{"SgExpression*"};
19000 static constexpr bool traverse{true};
19001 static constexpr auto mbr_ptr{&SgImageControlStatement::p_err_msg};
19002 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19003 using bind = Desc<SgImageControlStatement, SgExpression* SgImageControlStatement::*, &SgImageControlStatement::p_err_msg>;
19004};
19005template <> struct describe_field_t<SgImageControlStatement,SgExpression*,&SgImageControlStatement::p_acquired_lock> {
19007 using field_type = SgExpression*;
19008 static constexpr size_t position{3};
19009 static constexpr char const * const name{"acquired_lock"};
19010 static constexpr char const * const typestr{"SgExpression*"};
19011 static constexpr bool traverse{true};
19012 static constexpr auto mbr_ptr{&SgImageControlStatement::p_acquired_lock};
19013 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19014 using bind = Desc<SgImageControlStatement, SgExpression* SgImageControlStatement::*, &SgImageControlStatement::p_acquired_lock>;
19015};
19025template <> struct node_from_variant_t<466> { using type = SgImageControlStatement; };
19026
19027// Class: ImagPartOp
19028template <> struct describe_node_t<SgImagPartOp> {
19029 using node = SgImagPartOp;
19030 using base = SgUnaryOp;
19031 static constexpr char const * const name{"ImagPartOp"};
19032 static constexpr unsigned long variant{467};
19033 static constexpr bool concrete{true};
19034 using subclasses_t = mp::List<>;
19035 using fields_t = mp::List<>;
19036};
19037template <> struct node_from_variant_t<467> { using type = SgImagPartOp; };
19038
19039// Class: ImplicitStatement
19040template <> struct describe_field_t<SgImplicitStatement,bool,&SgImplicitStatement::p_implicit_none> {
19042 using field_type = bool;
19043 static constexpr size_t position{0};
19044 static constexpr char const * const name{"implicit_none"};
19045 static constexpr char const * const typestr{"bool"};
19046 static constexpr bool traverse{false};
19047 static constexpr auto mbr_ptr{&SgImplicitStatement::p_implicit_none};
19048 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19049 using bind = Desc<SgImplicitStatement, bool SgImplicitStatement::*, &SgImplicitStatement::p_implicit_none>;
19050};
19051template <> struct describe_field_t<SgImplicitStatement,SgImplicitStatement::implicit_spec_enum,&SgImplicitStatement::p_implicit_spec> {
19054 static constexpr size_t position{1};
19055 static constexpr char const * const name{"implicit_spec"};
19056 static constexpr char const * const typestr{"SgImplicitStatement::implicit_spec_enum"};
19057 static constexpr bool traverse{false};
19058 static constexpr auto mbr_ptr{&SgImplicitStatement::p_implicit_spec};
19059 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19060 using bind = Desc<SgImplicitStatement, SgImplicitStatement::implicit_spec_enum SgImplicitStatement::*, &SgImplicitStatement::p_implicit_spec>;
19061};
19062template <> struct describe_field_t<SgImplicitStatement,SgInitializedNamePtrList,&SgImplicitStatement::p_variables> {
19064 using field_type = SgInitializedNamePtrList;
19065 static constexpr size_t position{2};
19066 static constexpr char const * const name{"variables"};
19067 static constexpr char const * const typestr{"SgInitializedNamePtrList"};
19068 static constexpr bool traverse{true};
19069 static constexpr auto mbr_ptr{&SgImplicitStatement::p_variables};
19070 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19071 using bind = Desc<SgImplicitStatement, SgInitializedNamePtrList SgImplicitStatement::*, &SgImplicitStatement::p_variables>;
19072};
19082template <> struct node_from_variant_t<468> { using type = SgImplicitStatement; };
19083
19084// Class: ImpliedDo
19085template <> struct describe_field_t<SgImpliedDo,SgExpression*,&SgImpliedDo::p_do_var_initialization> {
19086 using parent = SgImpliedDo;
19087 using field_type = SgExpression*;
19088 static constexpr size_t position{0};
19089 static constexpr char const * const name{"do_var_initialization"};
19090 static constexpr char const * const typestr{"SgExpression*"};
19091 static constexpr bool traverse{true};
19092 static constexpr auto mbr_ptr{&SgImpliedDo::p_do_var_initialization};
19093 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19094 using bind = Desc<SgImpliedDo, SgExpression* SgImpliedDo::*, &SgImpliedDo::p_do_var_initialization>;
19095};
19096template <> struct describe_field_t<SgImpliedDo,SgExpression*,&SgImpliedDo::p_last_val> {
19097 using parent = SgImpliedDo;
19098 using field_type = SgExpression*;
19099 static constexpr size_t position{1};
19100 static constexpr char const * const name{"last_val"};
19101 static constexpr char const * const typestr{"SgExpression*"};
19102 static constexpr bool traverse{true};
19103 static constexpr auto mbr_ptr{&SgImpliedDo::p_last_val};
19104 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19105 using bind = Desc<SgImpliedDo, SgExpression* SgImpliedDo::*, &SgImpliedDo::p_last_val>;
19106};
19107template <> struct describe_field_t<SgImpliedDo,SgExpression*,&SgImpliedDo::p_increment> {
19108 using parent = SgImpliedDo;
19109 using field_type = SgExpression*;
19110 static constexpr size_t position{2};
19111 static constexpr char const * const name{"increment"};
19112 static constexpr char const * const typestr{"SgExpression*"};
19113 static constexpr bool traverse{true};
19114 static constexpr auto mbr_ptr{&SgImpliedDo::p_increment};
19115 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19116 using bind = Desc<SgImpliedDo, SgExpression* SgImpliedDo::*, &SgImpliedDo::p_increment>;
19117};
19118template <> struct describe_field_t<SgImpliedDo,SgExprListExp*,&SgImpliedDo::p_object_list> {
19119 using parent = SgImpliedDo;
19120 using field_type = SgExprListExp*;
19121 static constexpr size_t position{3};
19122 static constexpr char const * const name{"object_list"};
19123 static constexpr char const * const typestr{"SgExprListExp*"};
19124 static constexpr bool traverse{true};
19125 static constexpr auto mbr_ptr{&SgImpliedDo::p_object_list};
19126 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19127 using bind = Desc<SgImpliedDo, SgExprListExp* SgImpliedDo::*, &SgImpliedDo::p_object_list>;
19128};
19129template <> struct describe_field_t<SgImpliedDo,SgScopeStatement*,&SgImpliedDo::p_implied_do_scope> {
19130 using parent = SgImpliedDo;
19132 static constexpr size_t position{4};
19133 static constexpr char const * const name{"implied_do_scope"};
19134 static constexpr char const * const typestr{"SgScopeStatement*"};
19135 static constexpr bool traverse{false};
19136 static constexpr auto mbr_ptr{&SgImpliedDo::p_implied_do_scope};
19137 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19138 using bind = Desc<SgImpliedDo, SgScopeStatement* SgImpliedDo::*, &SgImpliedDo::p_implied_do_scope>;
19139};
19149template <> struct node_from_variant_t<469> { using type = SgImpliedDo; };
19150
19151// Class: ImportStatement
19152template <> struct describe_field_t<SgImportStatement,SgExpressionPtrList,&SgImportStatement::p_import_list> {
19153 using parent = SgImportStatement;
19154 using field_type = SgExpressionPtrList;
19155 static constexpr size_t position{0};
19156 static constexpr char const * const name{"import_list"};
19157 static constexpr char const * const typestr{"SgExpressionPtrList"};
19158 static constexpr bool traverse{false};
19159 static constexpr auto mbr_ptr{&SgImportStatement::p_import_list};
19160 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19161 using bind = Desc<SgImportStatement, SgExpressionPtrList SgImportStatement::*, &SgImportStatement::p_import_list>;
19162};
19164 using node = SgImportStatement;
19166 static constexpr char const * const name{"ImportStatement"};
19167 static constexpr unsigned long variant{470};
19168 static constexpr bool concrete{true};
19169 using subclasses_t = mp::List<>;
19171};
19172template <> struct node_from_variant_t<470> { using type = SgImportStatement; };
19173
19174// Class: IncidenceDirectedGraph
19175template <> struct describe_field_t<SgIncidenceDirectedGraph,rose_graph_integer_edge_hash_multimap,&SgIncidenceDirectedGraph::p_node_index_to_edge_multimap_edgesOut> {
19178 static constexpr size_t position{0};
19179 static constexpr char const * const name{"node_index_to_edge_multimap_edgesOut"};
19180 static constexpr char const * const typestr{"rose_graph_integer_edge_hash_multimap"};
19181 static constexpr bool traverse{false};
19182 static constexpr auto mbr_ptr{&SgIncidenceDirectedGraph::p_node_index_to_edge_multimap_edgesOut};
19183 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19184 using bind = Desc<SgIncidenceDirectedGraph, rose_graph_integer_edge_hash_multimap SgIncidenceDirectedGraph::*, &SgIncidenceDirectedGraph::p_node_index_to_edge_multimap_edgesOut>;
19185};
19186template <> struct describe_field_t<SgIncidenceDirectedGraph,rose_graph_integer_edge_hash_multimap,&SgIncidenceDirectedGraph::p_node_index_to_edge_multimap_edgesIn> {
19189 static constexpr size_t position{1};
19190 static constexpr char const * const name{"node_index_to_edge_multimap_edgesIn"};
19191 static constexpr char const * const typestr{"rose_graph_integer_edge_hash_multimap"};
19192 static constexpr bool traverse{false};
19193 static constexpr auto mbr_ptr{&SgIncidenceDirectedGraph::p_node_index_to_edge_multimap_edgesIn};
19194 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19195 using bind = Desc<SgIncidenceDirectedGraph, rose_graph_integer_edge_hash_multimap SgIncidenceDirectedGraph::*, &SgIncidenceDirectedGraph::p_node_index_to_edge_multimap_edgesIn>;
19196};
19206template <> struct node_from_variant_t<471> { using type = SgIncidenceDirectedGraph; };
19207
19208// Class: IncidenceUndirectedGraph
19211 using base = SgGraph;
19212 static constexpr char const * const name{"IncidenceUndirectedGraph"};
19213 static constexpr unsigned long variant{472};
19214 static constexpr bool concrete{true};
19215 using subclasses_t = mp::List<>;
19216 using fields_t = mp::List<>;
19217};
19218template <> struct node_from_variant_t<472> { using type = SgIncidenceUndirectedGraph; };
19219
19220// Class: IncludeDirectiveStatement
19221template <> struct describe_field_t<SgIncludeDirectiveStatement,SgHeaderFileBody*,&SgIncludeDirectiveStatement::p_headerFileBody> {
19224 static constexpr size_t position{0};
19225 static constexpr char const * const name{"headerFileBody"};
19226 static constexpr char const * const typestr{"SgHeaderFileBody*"};
19227 static constexpr bool traverse{true};
19228 static constexpr auto mbr_ptr{&SgIncludeDirectiveStatement::p_headerFileBody};
19229 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19230 using bind = Desc<SgIncludeDirectiveStatement, SgHeaderFileBody* SgIncludeDirectiveStatement::*, &SgIncludeDirectiveStatement::p_headerFileBody>;
19231};
19232template <> struct describe_field_t<SgIncludeDirectiveStatement,SgIncludeFile*,&SgIncludeDirectiveStatement::p_include_file_heirarchy> {
19234 using field_type = SgIncludeFile*;
19235 static constexpr size_t position{1};
19236 static constexpr char const * const name{"include_file_heirarchy"};
19237 static constexpr char const * const typestr{"SgIncludeFile*"};
19238 static constexpr bool traverse{false};
19239 static constexpr auto mbr_ptr{&SgIncludeDirectiveStatement::p_include_file_heirarchy};
19240 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19241 using bind = Desc<SgIncludeDirectiveStatement, SgIncludeFile* SgIncludeDirectiveStatement::*, &SgIncludeDirectiveStatement::p_include_file_heirarchy>;
19242};
19243template <> struct describe_field_t<SgIncludeDirectiveStatement,std::string,&SgIncludeDirectiveStatement::p_name_used_in_include_directive> {
19245 using field_type = std::string;
19246 static constexpr size_t position{2};
19247 static constexpr char const * const name{"name_used_in_include_directive"};
19248 static constexpr char const * const typestr{"std::string"};
19249 static constexpr bool traverse{false};
19250 static constexpr auto mbr_ptr{&SgIncludeDirectiveStatement::p_name_used_in_include_directive};
19251 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19252 using bind = Desc<SgIncludeDirectiveStatement, std::string SgIncludeDirectiveStatement::*, &SgIncludeDirectiveStatement::p_name_used_in_include_directive>;
19253};
19263template <> struct node_from_variant_t<473> { using type = SgIncludeDirectiveStatement; };
19264
19265// Class: IncludeFile
19266template <> struct describe_field_t<SgIncludeFile,SgName,&SgIncludeFile::p_filename> {
19267 using parent = SgIncludeFile;
19268 using field_type = SgName;
19269 static constexpr size_t position{0};
19270 static constexpr char const * const name{"filename"};
19271 static constexpr char const * const typestr{"SgName"};
19272 static constexpr bool traverse{false};
19273 static constexpr auto mbr_ptr{&SgIncludeFile::p_filename};
19274 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19275 using bind = Desc<SgIncludeFile, SgName SgIncludeFile::*, &SgIncludeFile::p_filename>;
19276};
19277template <> struct describe_field_t<SgIncludeFile,SgSourceFile*,&SgIncludeFile::p_source_file> {
19278 using parent = SgIncludeFile;
19279 using field_type = SgSourceFile*;
19280 static constexpr size_t position{1};
19281 static constexpr char const * const name{"source_file"};
19282 static constexpr char const * const typestr{"SgSourceFile*"};
19283 static constexpr bool traverse{false};
19284 static constexpr auto mbr_ptr{&SgIncludeFile::p_source_file};
19285 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19286 using bind = Desc<SgIncludeFile, SgSourceFile* SgIncludeFile::*, &SgIncludeFile::p_source_file>;
19287};
19288template <> struct describe_field_t<SgIncludeFile,SgIncludeFilePtrList,&SgIncludeFile::p_include_file_list> {
19289 using parent = SgIncludeFile;
19290 using field_type = SgIncludeFilePtrList;
19291 static constexpr size_t position{2};
19292 static constexpr char const * const name{"include_file_list"};
19293 static constexpr char const * const typestr{"SgIncludeFilePtrList"};
19294 static constexpr bool traverse{true};
19295 static constexpr auto mbr_ptr{&SgIncludeFile::p_include_file_list};
19296 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19297 using bind = Desc<SgIncludeFile, SgIncludeFilePtrList SgIncludeFile::*, &SgIncludeFile::p_include_file_list>;
19298};
19299template <> struct describe_field_t<SgIncludeFile,unsigned int,&SgIncludeFile::p_first_source_sequence_number> {
19300 using parent = SgIncludeFile;
19301 using field_type = unsigned int;
19302 static constexpr size_t position{3};
19303 static constexpr char const * const name{"first_source_sequence_number"};
19304 static constexpr char const * const typestr{"unsigned int"};
19305 static constexpr bool traverse{false};
19306 static constexpr auto mbr_ptr{&SgIncludeFile::p_first_source_sequence_number};
19307 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19308 using bind = Desc<SgIncludeFile, unsigned int SgIncludeFile::*, &SgIncludeFile::p_first_source_sequence_number>;
19309};
19310template <> struct describe_field_t<SgIncludeFile,unsigned int,&SgIncludeFile::p_last_source_sequence_number> {
19311 using parent = SgIncludeFile;
19312 using field_type = unsigned int;
19313 static constexpr size_t position{4};
19314 static constexpr char const * const name{"last_source_sequence_number"};
19315 static constexpr char const * const typestr{"unsigned int"};
19316 static constexpr bool traverse{false};
19317 static constexpr auto mbr_ptr{&SgIncludeFile::p_last_source_sequence_number};
19318 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19319 using bind = Desc<SgIncludeFile, unsigned int SgIncludeFile::*, &SgIncludeFile::p_last_source_sequence_number>;
19320};
19321template <> struct describe_field_t<SgIncludeFile,bool,&SgIncludeFile::p_isIncludedMoreThanOnce> {
19322 using parent = SgIncludeFile;
19323 using field_type = bool;
19324 static constexpr size_t position{5};
19325 static constexpr char const * const name{"isIncludedMoreThanOnce"};
19326 static constexpr char const * const typestr{"bool"};
19327 static constexpr bool traverse{false};
19328 static constexpr auto mbr_ptr{&SgIncludeFile::p_isIncludedMoreThanOnce};
19329 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19330 using bind = Desc<SgIncludeFile, bool SgIncludeFile::*, &SgIncludeFile::p_isIncludedMoreThanOnce>;
19331};
19332template <> struct describe_field_t<SgIncludeFile,bool,&SgIncludeFile::p_isPrimaryUse> {
19333 using parent = SgIncludeFile;
19334 using field_type = bool;
19335 static constexpr size_t position{6};
19336 static constexpr char const * const name{"isPrimaryUse"};
19337 static constexpr char const * const typestr{"bool"};
19338 static constexpr bool traverse{false};
19339 static constexpr auto mbr_ptr{&SgIncludeFile::p_isPrimaryUse};
19340 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19341 using bind = Desc<SgIncludeFile, bool SgIncludeFile::*, &SgIncludeFile::p_isPrimaryUse>;
19342};
19343template <> struct describe_field_t<SgIncludeFile,std::string,&SgIncludeFile::p_file_hash> {
19344 using parent = SgIncludeFile;
19345 using field_type = std::string;
19346 static constexpr size_t position{7};
19347 static constexpr char const * const name{"file_hash"};
19348 static constexpr char const * const typestr{"std::string"};
19349 static constexpr bool traverse{false};
19350 static constexpr auto mbr_ptr{&SgIncludeFile::p_file_hash};
19351 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19352 using bind = Desc<SgIncludeFile, std::string SgIncludeFile::*, &SgIncludeFile::p_file_hash>;
19353};
19354template <> struct describe_field_t<SgIncludeFile,SgName,&SgIncludeFile::p_name_used_in_include_directive> {
19355 using parent = SgIncludeFile;
19356 using field_type = SgName;
19357 static constexpr size_t position{8};
19358 static constexpr char const * const name{"name_used_in_include_directive"};
19359 static constexpr char const * const typestr{"SgName"};
19360 static constexpr bool traverse{false};
19361 static constexpr auto mbr_ptr{&SgIncludeFile::p_name_used_in_include_directive};
19362 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19363 using bind = Desc<SgIncludeFile, SgName SgIncludeFile::*, &SgIncludeFile::p_name_used_in_include_directive>;
19364};
19365template <> struct describe_field_t<SgIncludeFile,SgSourceFile*,&SgIncludeFile::p_source_file_of_translation_unit> {
19366 using parent = SgIncludeFile;
19367 using field_type = SgSourceFile*;
19368 static constexpr size_t position{9};
19369 static constexpr char const * const name{"source_file_of_translation_unit"};
19370 static constexpr char const * const typestr{"SgSourceFile*"};
19371 static constexpr bool traverse{false};
19372 static constexpr auto mbr_ptr{&SgIncludeFile::p_source_file_of_translation_unit};
19373 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19374 using bind = Desc<SgIncludeFile, SgSourceFile* SgIncludeFile::*, &SgIncludeFile::p_source_file_of_translation_unit>;
19375};
19376template <> struct describe_field_t<SgIncludeFile,SgSourceFile*,&SgIncludeFile::p_including_source_file> {
19377 using parent = SgIncludeFile;
19378 using field_type = SgSourceFile*;
19379 static constexpr size_t position{10};
19380 static constexpr char const * const name{"including_source_file"};
19381 static constexpr char const * const typestr{"SgSourceFile*"};
19382 static constexpr bool traverse{false};
19383 static constexpr auto mbr_ptr{&SgIncludeFile::p_including_source_file};
19384 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19385 using bind = Desc<SgIncludeFile, SgSourceFile* SgIncludeFile::*, &SgIncludeFile::p_including_source_file>;
19386};
19387template <> struct describe_field_t<SgIncludeFile,SgIncludeFile*,&SgIncludeFile::p_parent_include_file> {
19388 using parent = SgIncludeFile;
19389 using field_type = SgIncludeFile*;
19390 static constexpr size_t position{11};
19391 static constexpr char const * const name{"parent_include_file"};
19392 static constexpr char const * const typestr{"SgIncludeFile*"};
19393 static constexpr bool traverse{false};
19394 static constexpr auto mbr_ptr{&SgIncludeFile::p_parent_include_file};
19395 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19396 using bind = Desc<SgIncludeFile, SgIncludeFile* SgIncludeFile::*, &SgIncludeFile::p_parent_include_file>;
19397};
19398template <> struct describe_field_t<SgIncludeFile,bool,&SgIncludeFile::p_isSystemInclude> {
19399 using parent = SgIncludeFile;
19400 using field_type = bool;
19401 static constexpr size_t position{12};
19402 static constexpr char const * const name{"isSystemInclude"};
19403 static constexpr char const * const typestr{"bool"};
19404 static constexpr bool traverse{false};
19405 static constexpr auto mbr_ptr{&SgIncludeFile::p_isSystemInclude};
19406 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19407 using bind = Desc<SgIncludeFile, bool SgIncludeFile::*, &SgIncludeFile::p_isSystemInclude>;
19408};
19409template <> struct describe_field_t<SgIncludeFile,bool,&SgIncludeFile::p_isPreinclude> {
19410 using parent = SgIncludeFile;
19411 using field_type = bool;
19412 static constexpr size_t position{13};
19413 static constexpr char const * const name{"isPreinclude"};
19414 static constexpr char const * const typestr{"bool"};
19415 static constexpr bool traverse{false};
19416 static constexpr auto mbr_ptr{&SgIncludeFile::p_isPreinclude};
19417 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19418 using bind = Desc<SgIncludeFile, bool SgIncludeFile::*, &SgIncludeFile::p_isPreinclude>;
19419};
19420template <> struct describe_field_t<SgIncludeFile,bool,&SgIncludeFile::p_requires_explict_path_for_unparsed_headers> {
19421 using parent = SgIncludeFile;
19422 using field_type = bool;
19423 static constexpr size_t position{14};
19424 static constexpr char const * const name{"requires_explict_path_for_unparsed_headers"};
19425 static constexpr char const * const typestr{"bool"};
19426 static constexpr bool traverse{false};
19427 static constexpr auto mbr_ptr{&SgIncludeFile::p_requires_explict_path_for_unparsed_headers};
19428 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19429 using bind = Desc<SgIncludeFile, bool SgIncludeFile::*, &SgIncludeFile::p_requires_explict_path_for_unparsed_headers>;
19430};
19431template <> struct describe_field_t<SgIncludeFile,bool,&SgIncludeFile::p_can_be_supported_using_token_based_unparsing> {
19432 using parent = SgIncludeFile;
19433 using field_type = bool;
19434 static constexpr size_t position{15};
19435 static constexpr char const * const name{"can_be_supported_using_token_based_unparsing"};
19436 static constexpr char const * const typestr{"bool"};
19437 static constexpr bool traverse{false};
19438 static constexpr auto mbr_ptr{&SgIncludeFile::p_can_be_supported_using_token_based_unparsing};
19439 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19440 using bind = Desc<SgIncludeFile, bool SgIncludeFile::*, &SgIncludeFile::p_can_be_supported_using_token_based_unparsing>;
19441};
19442template <> struct describe_field_t<SgIncludeFile,SgName,&SgIncludeFile::p_directory_prefix> {
19443 using parent = SgIncludeFile;
19444 using field_type = SgName;
19445 static constexpr size_t position{16};
19446 static constexpr char const * const name{"directory_prefix"};
19447 static constexpr char const * const typestr{"SgName"};
19448 static constexpr bool traverse{false};
19449 static constexpr auto mbr_ptr{&SgIncludeFile::p_directory_prefix};
19450 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19451 using bind = Desc<SgIncludeFile, SgName SgIncludeFile::*, &SgIncludeFile::p_directory_prefix>;
19452};
19453template <> struct describe_field_t<SgIncludeFile,SgName,&SgIncludeFile::p_name_without_path> {
19454 using parent = SgIncludeFile;
19455 using field_type = SgName;
19456 static constexpr size_t position{17};
19457 static constexpr char const * const name{"name_without_path"};
19458 static constexpr char const * const typestr{"SgName"};
19459 static constexpr bool traverse{false};
19460 static constexpr auto mbr_ptr{&SgIncludeFile::p_name_without_path};
19461 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19462 using bind = Desc<SgIncludeFile, SgName SgIncludeFile::*, &SgIncludeFile::p_name_without_path>;
19463};
19464template <> struct describe_field_t<SgIncludeFile,SgName,&SgIncludeFile::p_applicationRootDirectory> {
19465 using parent = SgIncludeFile;
19466 using field_type = SgName;
19467 static constexpr size_t position{18};
19468 static constexpr char const * const name{"applicationRootDirectory"};
19469 static constexpr char const * const typestr{"SgName"};
19470 static constexpr bool traverse{false};
19471 static constexpr auto mbr_ptr{&SgIncludeFile::p_applicationRootDirectory};
19472 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19473 using bind = Desc<SgIncludeFile, SgName SgIncludeFile::*, &SgIncludeFile::p_applicationRootDirectory>;
19474};
19475template <> struct describe_field_t<SgIncludeFile,bool,&SgIncludeFile::p_will_be_unparsed> {
19476 using parent = SgIncludeFile;
19477 using field_type = bool;
19478 static constexpr size_t position{19};
19479 static constexpr char const * const name{"will_be_unparsed"};
19480 static constexpr char const * const typestr{"bool"};
19481 static constexpr bool traverse{false};
19482 static constexpr auto mbr_ptr{&SgIncludeFile::p_will_be_unparsed};
19483 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19484 using bind = Desc<SgIncludeFile, bool SgIncludeFile::*, &SgIncludeFile::p_will_be_unparsed>;
19485};
19486template <> struct describe_field_t<SgIncludeFile,bool,&SgIncludeFile::p_isRoseSystemInclude> {
19487 using parent = SgIncludeFile;
19488 using field_type = bool;
19489 static constexpr size_t position{20};
19490 static constexpr char const * const name{"isRoseSystemInclude"};
19491 static constexpr char const * const typestr{"bool"};
19492 static constexpr bool traverse{false};
19493 static constexpr auto mbr_ptr{&SgIncludeFile::p_isRoseSystemInclude};
19494 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19495 using bind = Desc<SgIncludeFile, bool SgIncludeFile::*, &SgIncludeFile::p_isRoseSystemInclude>;
19496};
19497template <> struct describe_field_t<SgIncludeFile,bool,&SgIncludeFile::p_from_system_include_dir> {
19498 using parent = SgIncludeFile;
19499 using field_type = bool;
19500 static constexpr size_t position{21};
19501 static constexpr char const * const name{"from_system_include_dir"};
19502 static constexpr char const * const typestr{"bool"};
19503 static constexpr bool traverse{false};
19504 static constexpr auto mbr_ptr{&SgIncludeFile::p_from_system_include_dir};
19505 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19506 using bind = Desc<SgIncludeFile, bool SgIncludeFile::*, &SgIncludeFile::p_from_system_include_dir>;
19507};
19508template <> struct describe_field_t<SgIncludeFile,bool,&SgIncludeFile::p_preinclude_macros_only> {
19509 using parent = SgIncludeFile;
19510 using field_type = bool;
19511 static constexpr size_t position{22};
19512 static constexpr char const * const name{"preinclude_macros_only"};
19513 static constexpr char const * const typestr{"bool"};
19514 static constexpr bool traverse{false};
19515 static constexpr auto mbr_ptr{&SgIncludeFile::p_preinclude_macros_only};
19516 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19517 using bind = Desc<SgIncludeFile, bool SgIncludeFile::*, &SgIncludeFile::p_preinclude_macros_only>;
19518};
19519template <> struct describe_field_t<SgIncludeFile,bool,&SgIncludeFile::p_isApplicationFile> {
19520 using parent = SgIncludeFile;
19521 using field_type = bool;
19522 static constexpr size_t position{23};
19523 static constexpr char const * const name{"isApplicationFile"};
19524 static constexpr char const * const typestr{"bool"};
19525 static constexpr bool traverse{false};
19526 static constexpr auto mbr_ptr{&SgIncludeFile::p_isApplicationFile};
19527 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19528 using bind = Desc<SgIncludeFile, bool SgIncludeFile::*, &SgIncludeFile::p_isApplicationFile>;
19529};
19530template <> struct describe_field_t<SgIncludeFile,bool,&SgIncludeFile::p_isRootSourceFile> {
19531 using parent = SgIncludeFile;
19532 using field_type = bool;
19533 static constexpr size_t position{24};
19534 static constexpr char const * const name{"isRootSourceFile"};
19535 static constexpr char const * const typestr{"bool"};
19536 static constexpr bool traverse{false};
19537 static constexpr auto mbr_ptr{&SgIncludeFile::p_isRootSourceFile};
19538 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19539 using bind = Desc<SgIncludeFile, bool SgIncludeFile::*, &SgIncludeFile::p_isRootSourceFile>;
19540};
19541template <> struct describe_field_t<SgIncludeFile,SgStatement*,&SgIncludeFile::p_firstStatement> {
19542 using parent = SgIncludeFile;
19543 using field_type = SgStatement*;
19544 static constexpr size_t position{25};
19545 static constexpr char const * const name{"firstStatement"};
19546 static constexpr char const * const typestr{"SgStatement*"};
19547 static constexpr bool traverse{false};
19548 static constexpr auto mbr_ptr{&SgIncludeFile::p_firstStatement};
19549 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19550 using bind = Desc<SgIncludeFile, SgStatement* SgIncludeFile::*, &SgIncludeFile::p_firstStatement>;
19551};
19552template <> struct describe_field_t<SgIncludeFile,SgStatement*,&SgIncludeFile::p_lastStatement> {
19553 using parent = SgIncludeFile;
19554 using field_type = SgStatement*;
19555 static constexpr size_t position{26};
19556 static constexpr char const * const name{"lastStatement"};
19557 static constexpr char const * const typestr{"SgStatement*"};
19558 static constexpr bool traverse{false};
19559 static constexpr auto mbr_ptr{&SgIncludeFile::p_lastStatement};
19560 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19561 using bind = Desc<SgIncludeFile, SgStatement* SgIncludeFile::*, &SgIncludeFile::p_lastStatement>;
19562};
19563template <> struct describe_node_t<SgIncludeFile> {
19564 using node = SgIncludeFile;
19565 using base = SgSupport;
19566 static constexpr char const * const name{"IncludeFile"};
19567 static constexpr unsigned long variant{474};
19568 static constexpr bool concrete{true};
19569 using subclasses_t = mp::List<>;
19570 using fields_t = mp::List<describe_field_t<SgIncludeFile,SgName,&SgIncludeFile::p_filename>, describe_field_t<SgIncludeFile,SgSourceFile*,&SgIncludeFile::p_source_file>, describe_field_t<SgIncludeFile,SgIncludeFilePtrList,&SgIncludeFile::p_include_file_list>, describe_field_t<SgIncludeFile,unsigned int,&SgIncludeFile::p_first_source_sequence_number>, describe_field_t<SgIncludeFile,unsigned int,&SgIncludeFile::p_last_source_sequence_number>, describe_field_t<SgIncludeFile,bool,&SgIncludeFile::p_isIncludedMoreThanOnce>, describe_field_t<SgIncludeFile,bool,&SgIncludeFile::p_isPrimaryUse>, describe_field_t<SgIncludeFile,std::string,&SgIncludeFile::p_file_hash>, describe_field_t<SgIncludeFile,SgName,&SgIncludeFile::p_name_used_in_include_directive>, describe_field_t<SgIncludeFile,SgSourceFile*,&SgIncludeFile::p_source_file_of_translation_unit>, describe_field_t<SgIncludeFile,SgSourceFile*,&SgIncludeFile::p_including_source_file>, describe_field_t<SgIncludeFile,SgIncludeFile*,&SgIncludeFile::p_parent_include_file>, describe_field_t<SgIncludeFile,bool,&SgIncludeFile::p_isSystemInclude>, describe_field_t<SgIncludeFile,bool,&SgIncludeFile::p_isPreinclude>, describe_field_t<SgIncludeFile,bool,&SgIncludeFile::p_requires_explict_path_for_unparsed_headers>, describe_field_t<SgIncludeFile,bool,&SgIncludeFile::p_can_be_supported_using_token_based_unparsing>, describe_field_t<SgIncludeFile,SgName,&SgIncludeFile::p_directory_prefix>, describe_field_t<SgIncludeFile,SgName,&SgIncludeFile::p_name_without_path>, describe_field_t<SgIncludeFile,SgName,&SgIncludeFile::p_applicationRootDirectory>, describe_field_t<SgIncludeFile,bool,&SgIncludeFile::p_will_be_unparsed>, describe_field_t<SgIncludeFile,bool,&SgIncludeFile::p_isRoseSystemInclude>, describe_field_t<SgIncludeFile,bool,&SgIncludeFile::p_from_system_include_dir>, describe_field_t<SgIncludeFile,bool,&SgIncludeFile::p_preinclude_macros_only>, describe_field_t<SgIncludeFile,bool,&SgIncludeFile::p_isApplicationFile>, describe_field_t<SgIncludeFile,bool,&SgIncludeFile::p_isRootSourceFile>, describe_field_t<SgIncludeFile,SgStatement*,&SgIncludeFile::p_firstStatement>, describe_field_t<SgIncludeFile,SgStatement*,&SgIncludeFile::p_lastStatement>>;
19571};
19572template <> struct node_from_variant_t<474> { using type = SgIncludeFile; };
19573
19574// Class: IncludeNextDirectiveStatement
19578 static constexpr char const * const name{"IncludeNextDirectiveStatement"};
19579 static constexpr unsigned long variant{475};
19580 static constexpr bool concrete{true};
19581 using subclasses_t = mp::List<>;
19582 using fields_t = mp::List<>;
19583};
19584template <> struct node_from_variant_t<475> { using type = SgIncludeNextDirectiveStatement; };
19585
19586// Class: InitializedName
19588 using parent = SgInitializedName;
19589 using field_type = SgName;
19590 static constexpr size_t position{0};
19591 static constexpr char const * const name{"name"};
19592 static constexpr char const * const typestr{"SgName"};
19593 static constexpr bool traverse{false};
19594 static constexpr auto mbr_ptr{&SgInitializedName::p_name};
19595 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19596 using bind = Desc<SgInitializedName, SgName SgInitializedName::*, &SgInitializedName::p_name>;
19597};
19598template <> struct describe_field_t<SgInitializedName,std::string,&SgInitializedName::p_microsoft_uuid_string> {
19599 using parent = SgInitializedName;
19600 using field_type = std::string;
19601 static constexpr size_t position{1};
19602 static constexpr char const * const name{"microsoft_uuid_string"};
19603 static constexpr char const * const typestr{"std::string"};
19604 static constexpr bool traverse{false};
19605 static constexpr auto mbr_ptr{&SgInitializedName::p_microsoft_uuid_string};
19606 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19607 using bind = Desc<SgInitializedName, std::string SgInitializedName::*, &SgInitializedName::p_microsoft_uuid_string>;
19608};
19610 using parent = SgInitializedName;
19611 using field_type = SgType*;
19612 static constexpr size_t position{2};
19613 static constexpr char const * const name{"typeptr"};
19614 static constexpr char const * const typestr{"SgType*"};
19615 static constexpr bool traverse{false};
19616 static constexpr auto mbr_ptr{&SgInitializedName::p_typeptr};
19617 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19618 using bind = Desc<SgInitializedName, SgType* SgInitializedName::*, &SgInitializedName::p_typeptr>;
19619};
19621 using parent = SgInitializedName;
19622 using field_type = SgInitializer*;
19623 static constexpr size_t position{3};
19624 static constexpr char const * const name{"initptr"};
19625 static constexpr char const * const typestr{"SgInitializer*"};
19626 static constexpr bool traverse{true};
19627 static constexpr auto mbr_ptr{&SgInitializedName::p_initptr};
19628 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19629 using bind = Desc<SgInitializedName, SgInitializer* SgInitializedName::*, &SgInitializedName::p_initptr>;
19630};
19632 using parent = SgInitializedName;
19634 static constexpr size_t position{4};
19635 static constexpr char const * const name{"prev_decl_item"};
19636 static constexpr char const * const typestr{"SgInitializedName*"};
19637 static constexpr bool traverse{false};
19638 static constexpr auto mbr_ptr{&SgInitializedName::p_prev_decl_item};
19639 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19640 using bind = Desc<SgInitializedName, SgInitializedName* SgInitializedName::*, &SgInitializedName::p_prev_decl_item>;
19641};
19643 using parent = SgInitializedName;
19644 using field_type = bool;
19645 static constexpr size_t position{5};
19646 static constexpr char const * const name{"is_initializer"};
19647 static constexpr char const * const typestr{"bool"};
19648 static constexpr bool traverse{false};
19649 static constexpr auto mbr_ptr{&SgInitializedName::p_is_initializer};
19650 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19651 using bind = Desc<SgInitializedName, bool SgInitializedName::*, &SgInitializedName::p_is_initializer>;
19652};
19654 using parent = SgInitializedName;
19656 static constexpr size_t position{6};
19657 static constexpr char const * const name{"declptr"};
19658 static constexpr char const * const typestr{"SgDeclarationStatement*"};
19659 static constexpr bool traverse{false};
19660 static constexpr auto mbr_ptr{&SgInitializedName::p_declptr};
19661 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19662 using bind = Desc<SgInitializedName, SgDeclarationStatement* SgInitializedName::*, &SgInitializedName::p_declptr>;
19663};
19665 using parent = SgInitializedName;
19667 static constexpr size_t position{7};
19668 static constexpr char const * const name{"storageModifier"};
19669 static constexpr char const * const typestr{"SgStorageModifier*"};
19670 static constexpr bool traverse{false};
19671 static constexpr auto mbr_ptr{&SgInitializedName::p_storageModifier};
19672 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19673 using bind = Desc<SgInitializedName, SgStorageModifier* SgInitializedName::*, &SgInitializedName::p_storageModifier>;
19674};
19676 using parent = SgInitializedName;
19678 static constexpr size_t position{8};
19679 static constexpr char const * const name{"scope"};
19680 static constexpr char const * const typestr{"SgScopeStatement*"};
19681 static constexpr bool traverse{false};
19682 static constexpr auto mbr_ptr{&SgInitializedName::p_scope};
19683 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19684 using bind = Desc<SgInitializedName, SgScopeStatement* SgInitializedName::*, &SgInitializedName::p_scope>;
19685};
19687 using parent = SgInitializedName;
19689 static constexpr size_t position{9};
19690 static constexpr char const * const name{"preinitialization"};
19691 static constexpr char const * const typestr{"SgInitializedName::preinitialization_enum"};
19692 static constexpr bool traverse{false};
19693 static constexpr auto mbr_ptr{&SgInitializedName::p_preinitialization};
19694 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19695 using bind = Desc<SgInitializedName, SgInitializedName::preinitialization_enum SgInitializedName::*, &SgInitializedName::p_preinitialization>;
19696};
19697template <> struct describe_field_t<SgInitializedName,bool,&SgInitializedName::p_isCoArray> {
19698 using parent = SgInitializedName;
19699 using field_type = bool;
19700 static constexpr size_t position{10};
19701 static constexpr char const * const name{"isCoArray"};
19702 static constexpr char const * const typestr{"bool"};
19703 static constexpr bool traverse{false};
19704 static constexpr auto mbr_ptr{&SgInitializedName::p_isCoArray};
19705 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19706 using bind = Desc<SgInitializedName, bool SgInitializedName::*, &SgInitializedName::p_isCoArray>;
19707};
19709 using parent = SgInitializedName;
19711 static constexpr size_t position{11};
19712 static constexpr char const * const name{"register_name_code"};
19713 static constexpr char const * const typestr{"SgInitializedName::asm_register_name_enum"};
19714 static constexpr bool traverse{false};
19715 static constexpr auto mbr_ptr{&SgInitializedName::p_register_name_code};
19716 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19717 using bind = Desc<SgInitializedName, SgInitializedName::asm_register_name_enum SgInitializedName::*, &SgInitializedName::p_register_name_code>;
19718};
19719template <> struct describe_field_t<SgInitializedName,SgInitializedName::excess_specifier_enum,&SgInitializedName::p_excess_specifier> {
19720 using parent = SgInitializedName;
19721 using field_type = SgInitializedName::excess_specifier_enum;
19722 static constexpr size_t position{12};
19723 static constexpr char const * const name{"excess_specifier"};
19724 static constexpr char const * const typestr{"SgInitializedName::excess_specifier_enum"};
19725 static constexpr bool traverse{false};
19726 static constexpr auto mbr_ptr{&SgInitializedName::p_excess_specifier};
19727 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19728 using bind = Desc<SgInitializedName, SgInitializedName::excess_specifier_enum SgInitializedName::*, &SgInitializedName::p_excess_specifier>;
19729};
19730template <> struct describe_field_t<SgInitializedName,std::string,&SgInitializedName::p_register_name_string> {
19731 using parent = SgInitializedName;
19732 using field_type = std::string;
19733 static constexpr size_t position{13};
19734 static constexpr char const * const name{"register_name_string"};
19735 static constexpr char const * const typestr{"std::string"};
19736 static constexpr bool traverse{false};
19737 static constexpr auto mbr_ptr{&SgInitializedName::p_register_name_string};
19738 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19739 using bind = Desc<SgInitializedName, std::string SgInitializedName::*, &SgInitializedName::p_register_name_string>;
19740};
19741template <> struct describe_field_t<SgInitializedName,bool,&SgInitializedName::p_requiresGlobalNameQualificationOnType> {
19742 using parent = SgInitializedName;
19743 using field_type = bool;
19744 static constexpr size_t position{14};
19745 static constexpr char const * const name{"requiresGlobalNameQualificationOnType"};
19746 static constexpr char const * const typestr{"bool"};
19747 static constexpr bool traverse{false};
19748 static constexpr auto mbr_ptr{&SgInitializedName::p_requiresGlobalNameQualificationOnType};
19749 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19750 using bind = Desc<SgInitializedName, bool SgInitializedName::*, &SgInitializedName::p_requiresGlobalNameQualificationOnType>;
19751};
19752template <> struct describe_field_t<SgInitializedName,bool,&SgInitializedName::p_shapeDeferred> {
19753 using parent = SgInitializedName;
19754 using field_type = bool;
19755 static constexpr size_t position{15};
19756 static constexpr char const * const name{"shapeDeferred"};
19757 static constexpr char const * const typestr{"bool"};
19758 static constexpr bool traverse{false};
19759 static constexpr auto mbr_ptr{&SgInitializedName::p_shapeDeferred};
19760 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19761 using bind = Desc<SgInitializedName, bool SgInitializedName::*, &SgInitializedName::p_shapeDeferred>;
19762};
19763template <> struct describe_field_t<SgInitializedName,bool,&SgInitializedName::p_initializationDeferred> {
19764 using parent = SgInitializedName;
19765 using field_type = bool;
19766 static constexpr size_t position{16};
19767 static constexpr char const * const name{"initializationDeferred"};
19768 static constexpr char const * const typestr{"bool"};
19769 static constexpr bool traverse{false};
19770 static constexpr auto mbr_ptr{&SgInitializedName::p_initializationDeferred};
19771 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19772 using bind = Desc<SgInitializedName, bool SgInitializedName::*, &SgInitializedName::p_initializationDeferred>;
19773};
19774template <> struct describe_field_t<SgInitializedName,SgBitVector,&SgInitializedName::p_gnu_attribute_modifierVector> {
19775 using parent = SgInitializedName;
19776 using field_type = SgBitVector;
19777 static constexpr size_t position{17};
19778 static constexpr char const * const name{"gnu_attribute_modifierVector"};
19779 static constexpr char const * const typestr{"SgBitVector"};
19780 static constexpr bool traverse{false};
19781 static constexpr auto mbr_ptr{&SgInitializedName::p_gnu_attribute_modifierVector};
19782 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19783 using bind = Desc<SgInitializedName, SgBitVector SgInitializedName::*, &SgInitializedName::p_gnu_attribute_modifierVector>;
19784};
19785template <> struct describe_field_t<SgInitializedName,unsigned long int,&SgInitializedName::p_gnu_attribute_initialization_priority> {
19786 using parent = SgInitializedName;
19787 using field_type = unsigned long int;
19788 static constexpr size_t position{18};
19789 static constexpr char const * const name{"gnu_attribute_initialization_priority"};
19790 static constexpr char const * const typestr{"unsigned long int"};
19791 static constexpr bool traverse{false};
19792 static constexpr auto mbr_ptr{&SgInitializedName::p_gnu_attribute_initialization_priority};
19793 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19794 using bind = Desc<SgInitializedName, unsigned long int SgInitializedName::*, &SgInitializedName::p_gnu_attribute_initialization_priority>;
19795};
19796template <> struct describe_field_t<SgInitializedName,std::string,&SgInitializedName::p_gnu_attribute_named_weak_reference> {
19797 using parent = SgInitializedName;
19798 using field_type = std::string;
19799 static constexpr size_t position{19};
19800 static constexpr char const * const name{"gnu_attribute_named_weak_reference"};
19801 static constexpr char const * const typestr{"std::string"};
19802 static constexpr bool traverse{false};
19803 static constexpr auto mbr_ptr{&SgInitializedName::p_gnu_attribute_named_weak_reference};
19804 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19805 using bind = Desc<SgInitializedName, std::string SgInitializedName::*, &SgInitializedName::p_gnu_attribute_named_weak_reference>;
19806};
19807template <> struct describe_field_t<SgInitializedName,std::string,&SgInitializedName::p_gnu_attribute_named_alias> {
19808 using parent = SgInitializedName;
19809 using field_type = std::string;
19810 static constexpr size_t position{20};
19811 static constexpr char const * const name{"gnu_attribute_named_alias"};
19812 static constexpr char const * const typestr{"std::string"};
19813 static constexpr bool traverse{false};
19814 static constexpr auto mbr_ptr{&SgInitializedName::p_gnu_attribute_named_alias};
19815 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19816 using bind = Desc<SgInitializedName, std::string SgInitializedName::*, &SgInitializedName::p_gnu_attribute_named_alias>;
19817};
19818template <> struct describe_field_t<SgInitializedName,std::string,&SgInitializedName::p_gnu_attribute_cleanup_function> {
19819 using parent = SgInitializedName;
19820 using field_type = std::string;
19821 static constexpr size_t position{21};
19822 static constexpr char const * const name{"gnu_attribute_cleanup_function"};
19823 static constexpr char const * const typestr{"std::string"};
19824 static constexpr bool traverse{false};
19825 static constexpr auto mbr_ptr{&SgInitializedName::p_gnu_attribute_cleanup_function};
19826 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19827 using bind = Desc<SgInitializedName, std::string SgInitializedName::*, &SgInitializedName::p_gnu_attribute_cleanup_function>;
19828};
19829template <> struct describe_field_t<SgInitializedName,std::string,&SgInitializedName::p_gnu_attribute_section_name> {
19830 using parent = SgInitializedName;
19831 using field_type = std::string;
19832 static constexpr size_t position{22};
19833 static constexpr char const * const name{"gnu_attribute_section_name"};
19834 static constexpr char const * const typestr{"std::string"};
19835 static constexpr bool traverse{false};
19836 static constexpr auto mbr_ptr{&SgInitializedName::p_gnu_attribute_section_name};
19837 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19838 using bind = Desc<SgInitializedName, std::string SgInitializedName::*, &SgInitializedName::p_gnu_attribute_section_name>;
19839};
19840template <> struct describe_field_t<SgInitializedName,int,&SgInitializedName::p_gnu_attribute_alignment> {
19841 using parent = SgInitializedName;
19842 using field_type = int;
19843 static constexpr size_t position{23};
19844 static constexpr char const * const name{"gnu_attribute_alignment"};
19845 static constexpr char const * const typestr{"int"};
19846 static constexpr bool traverse{false};
19847 static constexpr auto mbr_ptr{&SgInitializedName::p_gnu_attribute_alignment};
19848 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19849 using bind = Desc<SgInitializedName, int SgInitializedName::*, &SgInitializedName::p_gnu_attribute_alignment>;
19850};
19851template <> struct describe_field_t<SgInitializedName,SgDeclarationModifier::gnu_declaration_visability_enum,&SgInitializedName::p_gnu_attribute_visability> {
19852 using parent = SgInitializedName;
19854 static constexpr size_t position{24};
19855 static constexpr char const * const name{"gnu_attribute_visability"};
19856 static constexpr char const * const typestr{"SgDeclarationModifier::gnu_declaration_visability_enum"};
19857 static constexpr bool traverse{false};
19858 static constexpr auto mbr_ptr{&SgInitializedName::p_gnu_attribute_visability};
19859 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19860 using bind = Desc<SgInitializedName, SgDeclarationModifier::gnu_declaration_visability_enum SgInitializedName::*, &SgInitializedName::p_gnu_attribute_visability>;
19861};
19862template <> struct describe_field_t<SgInitializedName,bool,&SgInitializedName::p_protected_declaration> {
19863 using parent = SgInitializedName;
19864 using field_type = bool;
19865 static constexpr size_t position{25};
19866 static constexpr char const * const name{"protected_declaration"};
19867 static constexpr char const * const typestr{"bool"};
19868 static constexpr bool traverse{false};
19869 static constexpr auto mbr_ptr{&SgInitializedName::p_protected_declaration};
19870 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19871 using bind = Desc<SgInitializedName, bool SgInitializedName::*, &SgInitializedName::p_protected_declaration>;
19872};
19873template <> struct describe_field_t<SgInitializedName,int,&SgInitializedName::p_name_qualification_length> {
19874 using parent = SgInitializedName;
19875 using field_type = int;
19876 static constexpr size_t position{26};
19877 static constexpr char const * const name{"name_qualification_length"};
19878 static constexpr char const * const typestr{"int"};
19879 static constexpr bool traverse{false};
19880 static constexpr auto mbr_ptr{&SgInitializedName::p_name_qualification_length};
19881 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19882 using bind = Desc<SgInitializedName, int SgInitializedName::*, &SgInitializedName::p_name_qualification_length>;
19883};
19884template <> struct describe_field_t<SgInitializedName,bool,&SgInitializedName::p_type_elaboration_required> {
19885 using parent = SgInitializedName;
19886 using field_type = bool;
19887 static constexpr size_t position{27};
19888 static constexpr char const * const name{"type_elaboration_required"};
19889 static constexpr char const * const typestr{"bool"};
19890 static constexpr bool traverse{false};
19891 static constexpr auto mbr_ptr{&SgInitializedName::p_type_elaboration_required};
19892 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19893 using bind = Desc<SgInitializedName, bool SgInitializedName::*, &SgInitializedName::p_type_elaboration_required>;
19894};
19895template <> struct describe_field_t<SgInitializedName,bool,&SgInitializedName::p_global_qualification_required> {
19896 using parent = SgInitializedName;
19897 using field_type = bool;
19898 static constexpr size_t position{28};
19899 static constexpr char const * const name{"global_qualification_required"};
19900 static constexpr char const * const typestr{"bool"};
19901 static constexpr bool traverse{false};
19902 static constexpr auto mbr_ptr{&SgInitializedName::p_global_qualification_required};
19903 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19904 using bind = Desc<SgInitializedName, bool SgInitializedName::*, &SgInitializedName::p_global_qualification_required>;
19905};
19906template <> struct describe_field_t<SgInitializedName,int,&SgInitializedName::p_name_qualification_length_for_type> {
19907 using parent = SgInitializedName;
19908 using field_type = int;
19909 static constexpr size_t position{29};
19910 static constexpr char const * const name{"name_qualification_length_for_type"};
19911 static constexpr char const * const typestr{"int"};
19912 static constexpr bool traverse{false};
19913 static constexpr auto mbr_ptr{&SgInitializedName::p_name_qualification_length_for_type};
19914 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19915 using bind = Desc<SgInitializedName, int SgInitializedName::*, &SgInitializedName::p_name_qualification_length_for_type>;
19916};
19917template <> struct describe_field_t<SgInitializedName,bool,&SgInitializedName::p_type_elaboration_required_for_type> {
19918 using parent = SgInitializedName;
19919 using field_type = bool;
19920 static constexpr size_t position{30};
19921 static constexpr char const * const name{"type_elaboration_required_for_type"};
19922 static constexpr char const * const typestr{"bool"};
19923 static constexpr bool traverse{false};
19924 static constexpr auto mbr_ptr{&SgInitializedName::p_type_elaboration_required_for_type};
19925 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19926 using bind = Desc<SgInitializedName, bool SgInitializedName::*, &SgInitializedName::p_type_elaboration_required_for_type>;
19927};
19928template <> struct describe_field_t<SgInitializedName,bool,&SgInitializedName::p_global_qualification_required_for_type> {
19929 using parent = SgInitializedName;
19930 using field_type = bool;
19931 static constexpr size_t position{31};
19932 static constexpr char const * const name{"global_qualification_required_for_type"};
19933 static constexpr char const * const typestr{"bool"};
19934 static constexpr bool traverse{false};
19935 static constexpr auto mbr_ptr{&SgInitializedName::p_global_qualification_required_for_type};
19936 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19937 using bind = Desc<SgInitializedName, bool SgInitializedName::*, &SgInitializedName::p_global_qualification_required_for_type>;
19938};
19939template <> struct describe_field_t<SgInitializedName,bool,&SgInitializedName::p_hasArrayTypeWithEmptyBracketSyntax> {
19940 using parent = SgInitializedName;
19941 using field_type = bool;
19942 static constexpr size_t position{32};
19943 static constexpr char const * const name{"hasArrayTypeWithEmptyBracketSyntax"};
19944 static constexpr char const * const typestr{"bool"};
19945 static constexpr bool traverse{false};
19946 static constexpr auto mbr_ptr{&SgInitializedName::p_hasArrayTypeWithEmptyBracketSyntax};
19947 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19948 using bind = Desc<SgInitializedName, bool SgInitializedName::*, &SgInitializedName::p_hasArrayTypeWithEmptyBracketSyntax>;
19949};
19950template <> struct describe_field_t<SgInitializedName,bool,&SgInitializedName::p_using_C11_Alignas_keyword> {
19951 using parent = SgInitializedName;
19952 using field_type = bool;
19953 static constexpr size_t position{33};
19954 static constexpr char const * const name{"using_C11_Alignas_keyword"};
19955 static constexpr char const * const typestr{"bool"};
19956 static constexpr bool traverse{false};
19957 static constexpr auto mbr_ptr{&SgInitializedName::p_using_C11_Alignas_keyword};
19958 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19959 using bind = Desc<SgInitializedName, bool SgInitializedName::*, &SgInitializedName::p_using_C11_Alignas_keyword>;
19960};
19961template <> struct describe_field_t<SgInitializedName,SgNode*,&SgInitializedName::p_constant_or_type_argument_for_Alignas_keyword> {
19962 using parent = SgInitializedName;
19963 using field_type = SgNode*;
19964 static constexpr size_t position{34};
19965 static constexpr char const * const name{"constant_or_type_argument_for_Alignas_keyword"};
19966 static constexpr char const * const typestr{"SgNode*"};
19967 static constexpr bool traverse{false};
19968 static constexpr auto mbr_ptr{&SgInitializedName::p_constant_or_type_argument_for_Alignas_keyword};
19969 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19970 using bind = Desc<SgInitializedName, SgNode* SgInitializedName::*, &SgInitializedName::p_constant_or_type_argument_for_Alignas_keyword>;
19971};
19972template <> struct describe_field_t<SgInitializedName,bool,&SgInitializedName::p_using_auto_keyword> {
19973 using parent = SgInitializedName;
19974 using field_type = bool;
19975 static constexpr size_t position{35};
19976 static constexpr char const * const name{"using_auto_keyword"};
19977 static constexpr char const * const typestr{"bool"};
19978 static constexpr bool traverse{false};
19979 static constexpr auto mbr_ptr{&SgInitializedName::p_using_auto_keyword};
19980 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19981 using bind = Desc<SgInitializedName, bool SgInitializedName::*, &SgInitializedName::p_using_auto_keyword>;
19982};
19983template <> struct describe_field_t<SgInitializedName,SgType *,&SgInitializedName::p_auto_decltype> {
19984 using parent = SgInitializedName;
19985 using field_type = SgType *;
19986 static constexpr size_t position{36};
19987 static constexpr char const * const name{"auto_decltype"};
19988 static constexpr char const * const typestr{"SgType *"};
19989 static constexpr bool traverse{false};
19990 static constexpr auto mbr_ptr{&SgInitializedName::p_auto_decltype};
19991 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
19992 using bind = Desc<SgInitializedName, SgType * SgInitializedName::*, &SgInitializedName::p_auto_decltype>;
19993};
19994template <> struct describe_field_t<SgInitializedName,bool,&SgInitializedName::p_using_device_keyword> {
19995 using parent = SgInitializedName;
19996 using field_type = bool;
19997 static constexpr size_t position{37};
19998 static constexpr char const * const name{"using_device_keyword"};
19999 static constexpr char const * const typestr{"bool"};
20000 static constexpr bool traverse{false};
20001 static constexpr auto mbr_ptr{&SgInitializedName::p_using_device_keyword};
20002 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20003 using bind = Desc<SgInitializedName, bool SgInitializedName::*, &SgInitializedName::p_using_device_keyword>;
20004};
20005template <> struct describe_field_t<SgInitializedName,bool,&SgInitializedName::p_is_braced_initialized> {
20006 using parent = SgInitializedName;
20007 using field_type = bool;
20008 static constexpr size_t position{38};
20009 static constexpr char const * const name{"is_braced_initialized"};
20010 static constexpr char const * const typestr{"bool"};
20011 static constexpr bool traverse{false};
20012 static constexpr auto mbr_ptr{&SgInitializedName::p_is_braced_initialized};
20013 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20014 using bind = Desc<SgInitializedName, bool SgInitializedName::*, &SgInitializedName::p_is_braced_initialized>;
20015};
20016template <> struct describe_field_t<SgInitializedName,bool,&SgInitializedName::p_using_assignment_copy_constructor_syntax> {
20017 using parent = SgInitializedName;
20018 using field_type = bool;
20019 static constexpr size_t position{39};
20020 static constexpr char const * const name{"using_assignment_copy_constructor_syntax"};
20021 static constexpr char const * const typestr{"bool"};
20022 static constexpr bool traverse{false};
20023 static constexpr auto mbr_ptr{&SgInitializedName::p_using_assignment_copy_constructor_syntax};
20024 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20025 using bind = Desc<SgInitializedName, bool SgInitializedName::*, &SgInitializedName::p_using_assignment_copy_constructor_syntax>;
20026};
20027template <> struct describe_field_t<SgInitializedName,bool,&SgInitializedName::p_needs_definitions> {
20028 using parent = SgInitializedName;
20029 using field_type = bool;
20030 static constexpr size_t position{40};
20031 static constexpr char const * const name{"needs_definitions"};
20032 static constexpr char const * const typestr{"bool"};
20033 static constexpr bool traverse{false};
20034 static constexpr auto mbr_ptr{&SgInitializedName::p_needs_definitions};
20035 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20036 using bind = Desc<SgInitializedName, bool SgInitializedName::*, &SgInitializedName::p_needs_definitions>;
20037};
20038template <> struct describe_field_t<SgInitializedName,bool,&SgInitializedName::p_is_parameter_pack> {
20039 using parent = SgInitializedName;
20040 using field_type = bool;
20041 static constexpr size_t position{41};
20042 static constexpr char const * const name{"is_parameter_pack"};
20043 static constexpr char const * const typestr{"bool"};
20044 static constexpr bool traverse{false};
20045 static constexpr auto mbr_ptr{&SgInitializedName::p_is_parameter_pack};
20046 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20047 using bind = Desc<SgInitializedName, bool SgInitializedName::*, &SgInitializedName::p_is_parameter_pack>;
20048};
20049template <> struct describe_field_t<SgInitializedName,bool,&SgInitializedName::p_is_pack_element> {
20050 using parent = SgInitializedName;
20051 using field_type = bool;
20052 static constexpr size_t position{42};
20053 static constexpr char const * const name{"is_pack_element"};
20054 static constexpr char const * const typestr{"bool"};
20055 static constexpr bool traverse{false};
20056 static constexpr auto mbr_ptr{&SgInitializedName::p_is_pack_element};
20057 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20058 using bind = Desc<SgInitializedName, bool SgInitializedName::*, &SgInitializedName::p_is_pack_element>;
20059};
20061 using node = SgInitializedName;
20062 using base = SgLocatedNodeSupport;
20063 static constexpr char const * const name{"InitializedName"};
20064 static constexpr unsigned long variant{476};
20065 static constexpr bool concrete{true};
20066 using subclasses_t = mp::List<>;
20067 using fields_t = mp::List<describe_field_t<SgInitializedName,SgName,&SgInitializedName::p_name>, describe_field_t<SgInitializedName,std::string,&SgInitializedName::p_microsoft_uuid_string>, describe_field_t<SgInitializedName,SgType*,&SgInitializedName::p_typeptr>, describe_field_t<SgInitializedName,SgInitializer*,&SgInitializedName::p_initptr>, describe_field_t<SgInitializedName,SgInitializedName*,&SgInitializedName::p_prev_decl_item>, describe_field_t<SgInitializedName,bool,&SgInitializedName::p_is_initializer>, describe_field_t<SgInitializedName,SgDeclarationStatement*,&SgInitializedName::p_declptr>, describe_field_t<SgInitializedName,SgStorageModifier*,&SgInitializedName::p_storageModifier>, describe_field_t<SgInitializedName,SgScopeStatement*,&SgInitializedName::p_scope>, describe_field_t<SgInitializedName,SgInitializedName::preinitialization_enum,&SgInitializedName::p_preinitialization>, describe_field_t<SgInitializedName,bool,&SgInitializedName::p_isCoArray>, describe_field_t<SgInitializedName,SgInitializedName::asm_register_name_enum,&SgInitializedName::p_register_name_code>, describe_field_t<SgInitializedName,SgInitializedName::excess_specifier_enum,&SgInitializedName::p_excess_specifier>, describe_field_t<SgInitializedName,std::string,&SgInitializedName::p_register_name_string>, describe_field_t<SgInitializedName,bool,&SgInitializedName::p_requiresGlobalNameQualificationOnType>, describe_field_t<SgInitializedName,bool,&SgInitializedName::p_shapeDeferred>, describe_field_t<SgInitializedName,bool,&SgInitializedName::p_initializationDeferred>, describe_field_t<SgInitializedName,SgBitVector,&SgInitializedName::p_gnu_attribute_modifierVector>, describe_field_t<SgInitializedName,unsigned long int,&SgInitializedName::p_gnu_attribute_initialization_priority>, describe_field_t<SgInitializedName,std::string,&SgInitializedName::p_gnu_attribute_named_weak_reference>, describe_field_t<SgInitializedName,std::string,&SgInitializedName::p_gnu_attribute_named_alias>, describe_field_t<SgInitializedName,std::string,&SgInitializedName::p_gnu_attribute_cleanup_function>, describe_field_t<SgInitializedName,std::string,&SgInitializedName::p_gnu_attribute_section_name>, describe_field_t<SgInitializedName,int,&SgInitializedName::p_gnu_attribute_alignment>, describe_field_t<SgInitializedName,SgDeclarationModifier::gnu_declaration_visability_enum,&SgInitializedName::p_gnu_attribute_visability>, describe_field_t<SgInitializedName,bool,&SgInitializedName::p_protected_declaration>, describe_field_t<SgInitializedName,int,&SgInitializedName::p_name_qualification_length>, describe_field_t<SgInitializedName,bool,&SgInitializedName::p_type_elaboration_required>, describe_field_t<SgInitializedName,bool,&SgInitializedName::p_global_qualification_required>, describe_field_t<SgInitializedName,int,&SgInitializedName::p_name_qualification_length_for_type>, describe_field_t<SgInitializedName,bool,&SgInitializedName::p_type_elaboration_required_for_type>, describe_field_t<SgInitializedName,bool,&SgInitializedName::p_global_qualification_required_for_type>, describe_field_t<SgInitializedName,bool,&SgInitializedName::p_hasArrayTypeWithEmptyBracketSyntax>, describe_field_t<SgInitializedName,bool,&SgInitializedName::p_using_C11_Alignas_keyword>, describe_field_t<SgInitializedName,SgNode*,&SgInitializedName::p_constant_or_type_argument_for_Alignas_keyword>, describe_field_t<SgInitializedName,bool,&SgInitializedName::p_using_auto_keyword>, describe_field_t<SgInitializedName,SgType *,&SgInitializedName::p_auto_decltype>, describe_field_t<SgInitializedName,bool,&SgInitializedName::p_using_device_keyword>, describe_field_t<SgInitializedName,bool,&SgInitializedName::p_is_braced_initialized>, describe_field_t<SgInitializedName,bool,&SgInitializedName::p_using_assignment_copy_constructor_syntax>, describe_field_t<SgInitializedName,bool,&SgInitializedName::p_needs_definitions>, describe_field_t<SgInitializedName,bool,&SgInitializedName::p_is_parameter_pack>, describe_field_t<SgInitializedName,bool,&SgInitializedName::p_is_pack_element>>;
20068};
20069template <> struct node_from_variant_t<476> { using type = SgInitializedName; };
20070
20071// Class: Initializer
20073 using parent = SgInitializer;
20074 using field_type = bool;
20075 static constexpr size_t position{0};
20076 static constexpr char const * const name{"is_explicit_cast"};
20077 static constexpr char const * const typestr{"bool"};
20078 static constexpr bool traverse{false};
20079 static constexpr auto mbr_ptr{&SgInitializer::p_is_explicit_cast};
20080 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20081 using bind = Desc<SgInitializer, bool SgInitializer::*, &SgInitializer::p_is_explicit_cast>;
20082};
20083template <> struct describe_field_t<SgInitializer,bool,&SgInitializer::p_is_braced_initialized> {
20084 using parent = SgInitializer;
20085 using field_type = bool;
20086 static constexpr size_t position{1};
20087 static constexpr char const * const name{"is_braced_initialized"};
20088 static constexpr char const * const typestr{"bool"};
20089 static constexpr bool traverse{false};
20090 static constexpr auto mbr_ptr{&SgInitializer::p_is_braced_initialized};
20091 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20092 using bind = Desc<SgInitializer, bool SgInitializer::*, &SgInitializer::p_is_braced_initialized>;
20093};
20103template <> struct node_from_variant_t<477> { using type = SgInitializer; };
20104
20105// Class: InquireStatement
20106template <> struct describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_file> {
20107 using parent = SgInquireStatement;
20108 using field_type = SgExpression*;
20109 static constexpr size_t position{0};
20110 static constexpr char const * const name{"file"};
20111 static constexpr char const * const typestr{"SgExpression*"};
20112 static constexpr bool traverse{false};
20113 static constexpr auto mbr_ptr{&SgInquireStatement::p_file};
20114 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20115 using bind = Desc<SgInquireStatement, SgExpression* SgInquireStatement::*, &SgInquireStatement::p_file>;
20116};
20117template <> struct describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_access> {
20118 using parent = SgInquireStatement;
20119 using field_type = SgExpression*;
20120 static constexpr size_t position{1};
20121 static constexpr char const * const name{"access"};
20122 static constexpr char const * const typestr{"SgExpression*"};
20123 static constexpr bool traverse{false};
20124 static constexpr auto mbr_ptr{&SgInquireStatement::p_access};
20125 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20126 using bind = Desc<SgInquireStatement, SgExpression* SgInquireStatement::*, &SgInquireStatement::p_access>;
20127};
20128template <> struct describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_form> {
20129 using parent = SgInquireStatement;
20130 using field_type = SgExpression*;
20131 static constexpr size_t position{2};
20132 static constexpr char const * const name{"form"};
20133 static constexpr char const * const typestr{"SgExpression*"};
20134 static constexpr bool traverse{false};
20135 static constexpr auto mbr_ptr{&SgInquireStatement::p_form};
20136 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20137 using bind = Desc<SgInquireStatement, SgExpression* SgInquireStatement::*, &SgInquireStatement::p_form>;
20138};
20139template <> struct describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_recl> {
20140 using parent = SgInquireStatement;
20141 using field_type = SgExpression*;
20142 static constexpr size_t position{3};
20143 static constexpr char const * const name{"recl"};
20144 static constexpr char const * const typestr{"SgExpression*"};
20145 static constexpr bool traverse{false};
20146 static constexpr auto mbr_ptr{&SgInquireStatement::p_recl};
20147 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20148 using bind = Desc<SgInquireStatement, SgExpression* SgInquireStatement::*, &SgInquireStatement::p_recl>;
20149};
20150template <> struct describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_blank> {
20151 using parent = SgInquireStatement;
20152 using field_type = SgExpression*;
20153 static constexpr size_t position{4};
20154 static constexpr char const * const name{"blank"};
20155 static constexpr char const * const typestr{"SgExpression*"};
20156 static constexpr bool traverse{false};
20157 static constexpr auto mbr_ptr{&SgInquireStatement::p_blank};
20158 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20159 using bind = Desc<SgInquireStatement, SgExpression* SgInquireStatement::*, &SgInquireStatement::p_blank>;
20160};
20161template <> struct describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_exist> {
20162 using parent = SgInquireStatement;
20163 using field_type = SgExpression*;
20164 static constexpr size_t position{5};
20165 static constexpr char const * const name{"exist"};
20166 static constexpr char const * const typestr{"SgExpression*"};
20167 static constexpr bool traverse{false};
20168 static constexpr auto mbr_ptr{&SgInquireStatement::p_exist};
20169 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20170 using bind = Desc<SgInquireStatement, SgExpression* SgInquireStatement::*, &SgInquireStatement::p_exist>;
20171};
20172template <> struct describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_opened> {
20173 using parent = SgInquireStatement;
20174 using field_type = SgExpression*;
20175 static constexpr size_t position{6};
20176 static constexpr char const * const name{"opened"};
20177 static constexpr char const * const typestr{"SgExpression*"};
20178 static constexpr bool traverse{false};
20179 static constexpr auto mbr_ptr{&SgInquireStatement::p_opened};
20180 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20181 using bind = Desc<SgInquireStatement, SgExpression* SgInquireStatement::*, &SgInquireStatement::p_opened>;
20182};
20183template <> struct describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_number> {
20184 using parent = SgInquireStatement;
20185 using field_type = SgExpression*;
20186 static constexpr size_t position{7};
20187 static constexpr char const * const name{"number"};
20188 static constexpr char const * const typestr{"SgExpression*"};
20189 static constexpr bool traverse{false};
20190 static constexpr auto mbr_ptr{&SgInquireStatement::p_number};
20191 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20192 using bind = Desc<SgInquireStatement, SgExpression* SgInquireStatement::*, &SgInquireStatement::p_number>;
20193};
20194template <> struct describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_named> {
20195 using parent = SgInquireStatement;
20196 using field_type = SgExpression*;
20197 static constexpr size_t position{8};
20198 static constexpr char const * const name{"named"};
20199 static constexpr char const * const typestr{"SgExpression*"};
20200 static constexpr bool traverse{false};
20201 static constexpr auto mbr_ptr{&SgInquireStatement::p_named};
20202 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20203 using bind = Desc<SgInquireStatement, SgExpression* SgInquireStatement::*, &SgInquireStatement::p_named>;
20204};
20205template <> struct describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_name> {
20206 using parent = SgInquireStatement;
20207 using field_type = SgExpression*;
20208 static constexpr size_t position{9};
20209 static constexpr char const * const name{"name"};
20210 static constexpr char const * const typestr{"SgExpression*"};
20211 static constexpr bool traverse{false};
20212 static constexpr auto mbr_ptr{&SgInquireStatement::p_name};
20213 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20214 using bind = Desc<SgInquireStatement, SgExpression* SgInquireStatement::*, &SgInquireStatement::p_name>;
20215};
20216template <> struct describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_sequential> {
20217 using parent = SgInquireStatement;
20218 using field_type = SgExpression*;
20219 static constexpr size_t position{10};
20220 static constexpr char const * const name{"sequential"};
20221 static constexpr char const * const typestr{"SgExpression*"};
20222 static constexpr bool traverse{false};
20223 static constexpr auto mbr_ptr{&SgInquireStatement::p_sequential};
20224 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20225 using bind = Desc<SgInquireStatement, SgExpression* SgInquireStatement::*, &SgInquireStatement::p_sequential>;
20226};
20227template <> struct describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_direct> {
20228 using parent = SgInquireStatement;
20229 using field_type = SgExpression*;
20230 static constexpr size_t position{11};
20231 static constexpr char const * const name{"direct"};
20232 static constexpr char const * const typestr{"SgExpression*"};
20233 static constexpr bool traverse{false};
20234 static constexpr auto mbr_ptr{&SgInquireStatement::p_direct};
20235 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20236 using bind = Desc<SgInquireStatement, SgExpression* SgInquireStatement::*, &SgInquireStatement::p_direct>;
20237};
20238template <> struct describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_formatted> {
20239 using parent = SgInquireStatement;
20240 using field_type = SgExpression*;
20241 static constexpr size_t position{12};
20242 static constexpr char const * const name{"formatted"};
20243 static constexpr char const * const typestr{"SgExpression*"};
20244 static constexpr bool traverse{false};
20245 static constexpr auto mbr_ptr{&SgInquireStatement::p_formatted};
20246 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20247 using bind = Desc<SgInquireStatement, SgExpression* SgInquireStatement::*, &SgInquireStatement::p_formatted>;
20248};
20249template <> struct describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_unformatted> {
20250 using parent = SgInquireStatement;
20251 using field_type = SgExpression*;
20252 static constexpr size_t position{13};
20253 static constexpr char const * const name{"unformatted"};
20254 static constexpr char const * const typestr{"SgExpression*"};
20255 static constexpr bool traverse{false};
20256 static constexpr auto mbr_ptr{&SgInquireStatement::p_unformatted};
20257 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20258 using bind = Desc<SgInquireStatement, SgExpression* SgInquireStatement::*, &SgInquireStatement::p_unformatted>;
20259};
20260template <> struct describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_nextrec> {
20261 using parent = SgInquireStatement;
20262 using field_type = SgExpression*;
20263 static constexpr size_t position{14};
20264 static constexpr char const * const name{"nextrec"};
20265 static constexpr char const * const typestr{"SgExpression*"};
20266 static constexpr bool traverse{false};
20267 static constexpr auto mbr_ptr{&SgInquireStatement::p_nextrec};
20268 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20269 using bind = Desc<SgInquireStatement, SgExpression* SgInquireStatement::*, &SgInquireStatement::p_nextrec>;
20270};
20271template <> struct describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_position> {
20272 using parent = SgInquireStatement;
20273 using field_type = SgExpression*;
20274 static constexpr size_t position{15};
20275 static constexpr char const * const name{"position"};
20276 static constexpr char const * const typestr{"SgExpression*"};
20277 static constexpr bool traverse{false};
20278 static constexpr auto mbr_ptr{&SgInquireStatement::p_position};
20279 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20280 using bind = Desc<SgInquireStatement, SgExpression* SgInquireStatement::*, &SgInquireStatement::p_position>;
20281};
20282template <> struct describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_action> {
20283 using parent = SgInquireStatement;
20284 using field_type = SgExpression*;
20285 static constexpr size_t position{16};
20286 static constexpr char const * const name{"action"};
20287 static constexpr char const * const typestr{"SgExpression*"};
20288 static constexpr bool traverse{false};
20289 static constexpr auto mbr_ptr{&SgInquireStatement::p_action};
20290 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20291 using bind = Desc<SgInquireStatement, SgExpression* SgInquireStatement::*, &SgInquireStatement::p_action>;
20292};
20293template <> struct describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_read> {
20294 using parent = SgInquireStatement;
20295 using field_type = SgExpression*;
20296 static constexpr size_t position{17};
20297 static constexpr char const * const name{"read"};
20298 static constexpr char const * const typestr{"SgExpression*"};
20299 static constexpr bool traverse{false};
20300 static constexpr auto mbr_ptr{&SgInquireStatement::p_read};
20301 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20302 using bind = Desc<SgInquireStatement, SgExpression* SgInquireStatement::*, &SgInquireStatement::p_read>;
20303};
20304template <> struct describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_write> {
20305 using parent = SgInquireStatement;
20306 using field_type = SgExpression*;
20307 static constexpr size_t position{18};
20308 static constexpr char const * const name{"write"};
20309 static constexpr char const * const typestr{"SgExpression*"};
20310 static constexpr bool traverse{false};
20311 static constexpr auto mbr_ptr{&SgInquireStatement::p_write};
20312 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20313 using bind = Desc<SgInquireStatement, SgExpression* SgInquireStatement::*, &SgInquireStatement::p_write>;
20314};
20315template <> struct describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_readwrite> {
20316 using parent = SgInquireStatement;
20317 using field_type = SgExpression*;
20318 static constexpr size_t position{19};
20319 static constexpr char const * const name{"readwrite"};
20320 static constexpr char const * const typestr{"SgExpression*"};
20321 static constexpr bool traverse{false};
20322 static constexpr auto mbr_ptr{&SgInquireStatement::p_readwrite};
20323 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20324 using bind = Desc<SgInquireStatement, SgExpression* SgInquireStatement::*, &SgInquireStatement::p_readwrite>;
20325};
20326template <> struct describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_delim> {
20327 using parent = SgInquireStatement;
20328 using field_type = SgExpression*;
20329 static constexpr size_t position{20};
20330 static constexpr char const * const name{"delim"};
20331 static constexpr char const * const typestr{"SgExpression*"};
20332 static constexpr bool traverse{false};
20333 static constexpr auto mbr_ptr{&SgInquireStatement::p_delim};
20334 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20335 using bind = Desc<SgInquireStatement, SgExpression* SgInquireStatement::*, &SgInquireStatement::p_delim>;
20336};
20337template <> struct describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_pad> {
20338 using parent = SgInquireStatement;
20339 using field_type = SgExpression*;
20340 static constexpr size_t position{21};
20341 static constexpr char const * const name{"pad"};
20342 static constexpr char const * const typestr{"SgExpression*"};
20343 static constexpr bool traverse{false};
20344 static constexpr auto mbr_ptr{&SgInquireStatement::p_pad};
20345 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20346 using bind = Desc<SgInquireStatement, SgExpression* SgInquireStatement::*, &SgInquireStatement::p_pad>;
20347};
20348template <> struct describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_asynchronous> {
20349 using parent = SgInquireStatement;
20350 using field_type = SgExpression*;
20351 static constexpr size_t position{22};
20352 static constexpr char const * const name{"asynchronous"};
20353 static constexpr char const * const typestr{"SgExpression*"};
20354 static constexpr bool traverse{false};
20355 static constexpr auto mbr_ptr{&SgInquireStatement::p_asynchronous};
20356 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20357 using bind = Desc<SgInquireStatement, SgExpression* SgInquireStatement::*, &SgInquireStatement::p_asynchronous>;
20358};
20359template <> struct describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_decimal> {
20360 using parent = SgInquireStatement;
20361 using field_type = SgExpression*;
20362 static constexpr size_t position{23};
20363 static constexpr char const * const name{"decimal"};
20364 static constexpr char const * const typestr{"SgExpression*"};
20365 static constexpr bool traverse{false};
20366 static constexpr auto mbr_ptr{&SgInquireStatement::p_decimal};
20367 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20368 using bind = Desc<SgInquireStatement, SgExpression* SgInquireStatement::*, &SgInquireStatement::p_decimal>;
20369};
20370template <> struct describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_stream> {
20371 using parent = SgInquireStatement;
20372 using field_type = SgExpression*;
20373 static constexpr size_t position{24};
20374 static constexpr char const * const name{"stream"};
20375 static constexpr char const * const typestr{"SgExpression*"};
20376 static constexpr bool traverse{false};
20377 static constexpr auto mbr_ptr{&SgInquireStatement::p_stream};
20378 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20379 using bind = Desc<SgInquireStatement, SgExpression* SgInquireStatement::*, &SgInquireStatement::p_stream>;
20380};
20381template <> struct describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_size> {
20382 using parent = SgInquireStatement;
20383 using field_type = SgExpression*;
20384 static constexpr size_t position{25};
20385 static constexpr char const * const name{"size"};
20386 static constexpr char const * const typestr{"SgExpression*"};
20387 static constexpr bool traverse{false};
20388 static constexpr auto mbr_ptr{&SgInquireStatement::p_size};
20389 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20390 using bind = Desc<SgInquireStatement, SgExpression* SgInquireStatement::*, &SgInquireStatement::p_size>;
20391};
20392template <> struct describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_pending> {
20393 using parent = SgInquireStatement;
20394 using field_type = SgExpression*;
20395 static constexpr size_t position{26};
20396 static constexpr char const * const name{"pending"};
20397 static constexpr char const * const typestr{"SgExpression*"};
20398 static constexpr bool traverse{false};
20399 static constexpr auto mbr_ptr{&SgInquireStatement::p_pending};
20400 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20401 using bind = Desc<SgInquireStatement, SgExpression* SgInquireStatement::*, &SgInquireStatement::p_pending>;
20402};
20403template <> struct describe_field_t<SgInquireStatement,SgVarRefExp*,&SgInquireStatement::p_iolengthExp> {
20404 using parent = SgInquireStatement;
20405 using field_type = SgVarRefExp*;
20406 static constexpr size_t position{27};
20407 static constexpr char const * const name{"iolengthExp"};
20408 static constexpr char const * const typestr{"SgVarRefExp*"};
20409 static constexpr bool traverse{false};
20410 static constexpr auto mbr_ptr{&SgInquireStatement::p_iolengthExp};
20411 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20412 using bind = Desc<SgInquireStatement, SgVarRefExp* SgInquireStatement::*, &SgInquireStatement::p_iolengthExp>;
20413};
20415 using node = SgInquireStatement;
20416 using base = SgIOStatement;
20417 static constexpr char const * const name{"InquireStatement"};
20418 static constexpr unsigned long variant{478};
20419 static constexpr bool concrete{true};
20420 using subclasses_t = mp::List<>;
20421 using fields_t = mp::List<describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_file>, describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_access>, describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_form>, describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_recl>, describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_blank>, describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_exist>, describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_opened>, describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_number>, describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_named>, describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_name>, describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_sequential>, describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_direct>, describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_formatted>, describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_unformatted>, describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_nextrec>, describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_position>, describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_action>, describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_read>, describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_write>, describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_readwrite>, describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_delim>, describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_pad>, describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_asynchronous>, describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_decimal>, describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_stream>, describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_size>, describe_field_t<SgInquireStatement,SgExpression*,&SgInquireStatement::p_pending>, describe_field_t<SgInquireStatement,SgVarRefExp*,&SgInquireStatement::p_iolengthExp>>;
20422};
20423template <> struct node_from_variant_t<478> { using type = SgInquireStatement; };
20424
20425// Class: IntKeyedBidirectionalGraph
20428 using base = SgBidirectionalGraph;
20429 static constexpr char const * const name{"IntKeyedBidirectionalGraph"};
20430 static constexpr unsigned long variant{479};
20431 static constexpr bool concrete{true};
20432 using subclasses_t = mp::List<>;
20433 using fields_t = mp::List<>;
20434};
20435template <> struct node_from_variant_t<479> { using type = SgIntKeyedBidirectionalGraph; };
20436
20437// Class: IntVal
20438template <> struct describe_field_t<SgIntVal,int,&SgIntVal::p_value> {
20439 using parent = SgIntVal;
20440 using field_type = int;
20441 static constexpr size_t position{0};
20442 static constexpr char const * const name{"value"};
20443 static constexpr char const * const typestr{"int"};
20444 static constexpr bool traverse{false};
20445 static constexpr auto mbr_ptr{&SgIntVal::p_value};
20446 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20447 using bind = Desc<SgIntVal, int SgIntVal::*, &SgIntVal::p_value>;
20448};
20449template <> struct describe_field_t<SgIntVal,std::string,&SgIntVal::p_valueString> {
20450 using parent = SgIntVal;
20451 using field_type = std::string;
20452 static constexpr size_t position{1};
20453 static constexpr char const * const name{"valueString"};
20454 static constexpr char const * const typestr{"std::string"};
20455 static constexpr bool traverse{false};
20456 static constexpr auto mbr_ptr{&SgIntVal::p_valueString};
20457 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20458 using bind = Desc<SgIntVal, std::string SgIntVal::*, &SgIntVal::p_valueString>;
20459};
20460template <> struct describe_node_t<SgIntVal> {
20461 using node = SgIntVal;
20462 using base = SgValueExp;
20463 static constexpr char const * const name{"IntVal"};
20464 static constexpr unsigned long variant{480};
20465 static constexpr bool concrete{true};
20466 using subclasses_t = mp::List<>;
20468};
20469template <> struct node_from_variant_t<480> { using type = SgIntVal; };
20470
20471// Class: IntegerDivideOp
20473 using node = SgIntegerDivideOp;
20474 using base = SgBinaryOp;
20475 static constexpr char const * const name{"IntegerDivideOp"};
20476 static constexpr unsigned long variant{481};
20477 static constexpr bool concrete{true};
20478 using subclasses_t = mp::List<>;
20479 using fields_t = mp::List<>;
20480};
20481template <> struct node_from_variant_t<481> { using type = SgIntegerDivideOp; };
20482
20483// Class: IntegerDivideAssignOp
20486 using base = SgCompoundAssignOp;
20487 static constexpr char const * const name{"IntegerDivideAssignOp"};
20488 static constexpr unsigned long variant{482};
20489 static constexpr bool concrete{true};
20490 using subclasses_t = mp::List<>;
20491 using fields_t = mp::List<>;
20492};
20493template <> struct node_from_variant_t<482> { using type = SgIntegerDivideAssignOp; };
20494
20495// Class: InterfaceBody
20496template <> struct describe_field_t<SgInterfaceBody,SgName,&SgInterfaceBody::p_function_name> {
20497 using parent = SgInterfaceBody;
20498 using field_type = SgName;
20499 static constexpr size_t position{0};
20500 static constexpr char const * const name{"function_name"};
20501 static constexpr char const * const typestr{"SgName"};
20502 static constexpr bool traverse{false};
20503 static constexpr auto mbr_ptr{&SgInterfaceBody::p_function_name};
20504 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20505 using bind = Desc<SgInterfaceBody, SgName SgInterfaceBody::*, &SgInterfaceBody::p_function_name>;
20506};
20507template <> struct describe_field_t<SgInterfaceBody,SgFunctionDeclaration*,&SgInterfaceBody::p_functionDeclaration> {
20508 using parent = SgInterfaceBody;
20510 static constexpr size_t position{1};
20511 static constexpr char const * const name{"functionDeclaration"};
20512 static constexpr char const * const typestr{"SgFunctionDeclaration*"};
20513 static constexpr bool traverse{false};
20514 static constexpr auto mbr_ptr{&SgInterfaceBody::p_functionDeclaration};
20515 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20516 using bind = Desc<SgInterfaceBody, SgFunctionDeclaration* SgInterfaceBody::*, &SgInterfaceBody::p_functionDeclaration>;
20517};
20518template <> struct describe_field_t<SgInterfaceBody,bool,&SgInterfaceBody::p_use_function_name> {
20519 using parent = SgInterfaceBody;
20520 using field_type = bool;
20521 static constexpr size_t position{2};
20522 static constexpr char const * const name{"use_function_name"};
20523 static constexpr char const * const typestr{"bool"};
20524 static constexpr bool traverse{false};
20525 static constexpr auto mbr_ptr{&SgInterfaceBody::p_use_function_name};
20526 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20527 using bind = Desc<SgInterfaceBody, bool SgInterfaceBody::*, &SgInterfaceBody::p_use_function_name>;
20528};
20530 using node = SgInterfaceBody;
20531 using base = SgLocatedNodeSupport;
20532 static constexpr char const * const name{"InterfaceBody"};
20533 static constexpr unsigned long variant{483};
20534 static constexpr bool concrete{true};
20535 using subclasses_t = mp::List<>;
20537};
20538template <> struct node_from_variant_t<483> { using type = SgInterfaceBody; };
20539
20540// Class: HeaderFileBody
20541template <> struct describe_field_t<SgHeaderFileBody,SgSourceFile*,&SgHeaderFileBody::p_include_file> {
20542 using parent = SgHeaderFileBody;
20543 using field_type = SgSourceFile*;
20544 static constexpr size_t position{0};
20545 static constexpr char const * const name{"include_file"};
20546 static constexpr char const * const typestr{"SgSourceFile*"};
20547 static constexpr bool traverse{false};
20548 static constexpr auto mbr_ptr{&SgHeaderFileBody::p_include_file};
20549 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20550 using bind = Desc<SgHeaderFileBody, SgSourceFile* SgHeaderFileBody::*, &SgHeaderFileBody::p_include_file>;
20551};
20553 using node = SgHeaderFileBody;
20554 using base = SgLocatedNodeSupport;
20555 static constexpr char const * const name{"HeaderFileBody"};
20556 static constexpr unsigned long variant{484};
20557 static constexpr bool concrete{true};
20558 using subclasses_t = mp::List<>;
20560};
20561template <> struct node_from_variant_t<484> { using type = SgHeaderFileBody; };
20562
20563// Class: HeaderFileReport
20564template <> struct describe_field_t<SgHeaderFileReport,SgSourceFile*,&SgHeaderFileReport::p_source_file> {
20565 using parent = SgHeaderFileReport;
20566 using field_type = SgSourceFile*;
20567 static constexpr size_t position{0};
20568 static constexpr char const * const name{"source_file"};
20569 static constexpr char const * const typestr{"SgSourceFile*"};
20570 static constexpr bool traverse{false};
20571 static constexpr auto mbr_ptr{&SgHeaderFileReport::p_source_file};
20572 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20573 using bind = Desc<SgHeaderFileReport, SgSourceFile* SgHeaderFileReport::*, &SgHeaderFileReport::p_source_file>;
20574};
20575template <> struct describe_field_t<SgHeaderFileReport,SgSourceFilePtrList,&SgHeaderFileReport::p_include_file_list> {
20576 using parent = SgHeaderFileReport;
20577 using field_type = SgSourceFilePtrList;
20578 static constexpr size_t position{1};
20579 static constexpr char const * const name{"include_file_list"};
20580 static constexpr char const * const typestr{"SgSourceFilePtrList"};
20581 static constexpr bool traverse{false};
20582 static constexpr auto mbr_ptr{&SgHeaderFileReport::p_include_file_list};
20583 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20584 using bind = Desc<SgHeaderFileReport, SgSourceFilePtrList SgHeaderFileReport::*, &SgHeaderFileReport::p_include_file_list>;
20585};
20587 using node = SgHeaderFileReport;
20588 using base = SgSupport;
20589 static constexpr char const * const name{"HeaderFileReport"};
20590 static constexpr unsigned long variant{485};
20591 static constexpr bool concrete{true};
20592 using subclasses_t = mp::List<>;
20594};
20595template <> struct node_from_variant_t<485> { using type = SgHeaderFileReport; };
20596
20597// Class: InterfaceStatement
20598template <> struct describe_field_t<SgInterfaceStatement,SgName,&SgInterfaceStatement::p_name> {
20600 using field_type = SgName;
20601 static constexpr size_t position{0};
20602 static constexpr char const * const name{"name"};
20603 static constexpr char const * const typestr{"SgName"};
20604 static constexpr bool traverse{false};
20605 static constexpr auto mbr_ptr{&SgInterfaceStatement::p_name};
20606 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20607 using bind = Desc<SgInterfaceStatement, SgName SgInterfaceStatement::*, &SgInterfaceStatement::p_name>;
20608};
20609template <> struct describe_field_t<SgInterfaceStatement,SgInterfaceStatement::generic_spec_enum,&SgInterfaceStatement::p_generic_spec> {
20612 static constexpr size_t position{1};
20613 static constexpr char const * const name{"generic_spec"};
20614 static constexpr char const * const typestr{"SgInterfaceStatement::generic_spec_enum"};
20615 static constexpr bool traverse{false};
20616 static constexpr auto mbr_ptr{&SgInterfaceStatement::p_generic_spec};
20617 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20618 using bind = Desc<SgInterfaceStatement, SgInterfaceStatement::generic_spec_enum SgInterfaceStatement::*, &SgInterfaceStatement::p_generic_spec>;
20619};
20620template <> struct describe_field_t<SgInterfaceStatement,SgInterfaceBodyPtrList,&SgInterfaceStatement::p_interface_body_list> {
20622 using field_type = SgInterfaceBodyPtrList;
20623 static constexpr size_t position{2};
20624 static constexpr char const * const name{"interface_body_list"};
20625 static constexpr char const * const typestr{"SgInterfaceBodyPtrList"};
20626 static constexpr bool traverse{true};
20627 static constexpr auto mbr_ptr{&SgInterfaceStatement::p_interface_body_list};
20628 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20629 using bind = Desc<SgInterfaceStatement, SgInterfaceBodyPtrList SgInterfaceStatement::*, &SgInterfaceStatement::p_interface_body_list>;
20630};
20631template <> struct describe_field_t<SgInterfaceStatement,SgLabelRefExp*,&SgInterfaceStatement::p_end_numeric_label> {
20633 using field_type = SgLabelRefExp*;
20634 static constexpr size_t position{3};
20635 static constexpr char const * const name{"end_numeric_label"};
20636 static constexpr char const * const typestr{"SgLabelRefExp*"};
20637 static constexpr bool traverse{false};
20638 static constexpr auto mbr_ptr{&SgInterfaceStatement::p_end_numeric_label};
20639 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20640 using bind = Desc<SgInterfaceStatement, SgLabelRefExp* SgInterfaceStatement::*, &SgInterfaceStatement::p_end_numeric_label>;
20641};
20651template <> struct node_from_variant_t<486> { using type = SgInterfaceStatement; };
20652
20653// Class: InterfaceSymbol
20654template <> struct describe_field_t<SgInterfaceSymbol,SgInterfaceStatement*,&SgInterfaceSymbol::p_declaration> {
20655 using parent = SgInterfaceSymbol;
20657 static constexpr size_t position{0};
20658 static constexpr char const * const name{"declaration"};
20659 static constexpr char const * const typestr{"SgInterfaceStatement*"};
20660 static constexpr bool traverse{false};
20661 static constexpr auto mbr_ptr{&SgInterfaceSymbol::p_declaration};
20662 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20663 using bind = Desc<SgInterfaceSymbol, SgInterfaceStatement* SgInterfaceSymbol::*, &SgInterfaceSymbol::p_declaration>;
20664};
20666 using node = SgInterfaceSymbol;
20667 using base = SgSymbol;
20668 static constexpr char const * const name{"InterfaceSymbol"};
20669 static constexpr unsigned long variant{487};
20670 static constexpr bool concrete{true};
20671 using subclasses_t = mp::List<>;
20673};
20674template <> struct node_from_variant_t<487> { using type = SgInterfaceSymbol; };
20675
20676// Class: IntrinsicSymbol
20677template <> struct describe_field_t<SgIntrinsicSymbol,SgInitializedName*,&SgIntrinsicSymbol::p_declaration> {
20678 using parent = SgIntrinsicSymbol;
20680 static constexpr size_t position{0};
20681 static constexpr char const * const name{"declaration"};
20682 static constexpr char const * const typestr{"SgInitializedName*"};
20683 static constexpr bool traverse{false};
20684 static constexpr auto mbr_ptr{&SgIntrinsicSymbol::p_declaration};
20685 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20686 using bind = Desc<SgIntrinsicSymbol, SgInitializedName* SgIntrinsicSymbol::*, &SgIntrinsicSymbol::p_declaration>;
20687};
20689 using node = SgIntrinsicSymbol;
20690 using base = SgSymbol;
20691 static constexpr char const * const name{"IntrinsicSymbol"};
20692 static constexpr unsigned long variant{488};
20693 static constexpr bool concrete{true};
20694 using subclasses_t = mp::List<>;
20696};
20697template <> struct node_from_variant_t<488> { using type = SgIntrinsicSymbol; };
20698
20699// Class: IsOp
20700template <> struct describe_node_t<SgIsOp> {
20701 using node = SgIsOp;
20702 using base = SgBinaryOp;
20703 static constexpr char const * const name{"IsOp"};
20704 static constexpr unsigned long variant{489};
20705 static constexpr bool concrete{true};
20706 using subclasses_t = mp::List<>;
20707 using fields_t = mp::List<>;
20708};
20709template <> struct node_from_variant_t<489> { using type = SgIsOp; };
20710
20711// Class: IsNotOp
20712template <> struct describe_node_t<SgIsNotOp> {
20713 using node = SgIsNotOp;
20714 using base = SgBinaryOp;
20715 static constexpr char const * const name{"IsNotOp"};
20716 static constexpr unsigned long variant{490};
20717 static constexpr bool concrete{true};
20718 using subclasses_t = mp::List<>;
20719 using fields_t = mp::List<>;
20720};
20721template <> struct node_from_variant_t<490> { using type = SgIsNotOp; };
20722
20723// Class: IorAssignOp
20724template <> struct describe_node_t<SgIorAssignOp> {
20725 using node = SgIorAssignOp;
20726 using base = SgCompoundAssignOp;
20727 static constexpr char const * const name{"IorAssignOp"};
20728 static constexpr unsigned long variant{491};
20729 static constexpr bool concrete{true};
20730 using subclasses_t = mp::List<>;
20731 using fields_t = mp::List<>;
20732};
20733template <> struct node_from_variant_t<491> { using type = SgIorAssignOp; };
20734
20735// Class: JovialBitType
20736template <> struct describe_field_t<SgJovialBitType,SgExpression*,&SgJovialBitType::p_size> {
20737 using parent = SgJovialBitType;
20738 using field_type = SgExpression*;
20739 static constexpr size_t position{0};
20740 static constexpr char const * const name{"size"};
20741 static constexpr char const * const typestr{"SgExpression*"};
20742 static constexpr bool traverse{false};
20743 static constexpr auto mbr_ptr{&SgJovialBitType::p_size};
20744 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20745 using bind = Desc<SgJovialBitType, SgExpression* SgJovialBitType::*, &SgJovialBitType::p_size>;
20746};
20748 using node = SgJovialBitType;
20749 using base = SgType;
20750 static constexpr char const * const name{"JovialBitType"};
20751 static constexpr unsigned long variant{492};
20752 static constexpr bool concrete{true};
20753 using subclasses_t = mp::List<>;
20755};
20756template <> struct node_from_variant_t<492> { using type = SgJovialBitType; };
20757
20758// Class: JovialBitVal
20759template <> struct describe_field_t<SgJovialBitVal,std::string,&SgJovialBitVal::p_valueString> {
20760 using parent = SgJovialBitVal;
20761 using field_type = std::string;
20762 static constexpr size_t position{0};
20763 static constexpr char const * const name{"valueString"};
20764 static constexpr char const * const typestr{"std::string"};
20765 static constexpr bool traverse{false};
20766 static constexpr auto mbr_ptr{&SgJovialBitVal::p_valueString};
20767 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20768 using bind = Desc<SgJovialBitVal, std::string SgJovialBitVal::*, &SgJovialBitVal::p_valueString>;
20769};
20770template <> struct describe_node_t<SgJovialBitVal> {
20771 using node = SgJovialBitVal;
20772 using base = SgValueExp;
20773 static constexpr char const * const name{"JovialBitVal"};
20774 static constexpr unsigned long variant{493};
20775 static constexpr bool concrete{true};
20776 using subclasses_t = mp::List<>;
20778};
20779template <> struct node_from_variant_t<493> { using type = SgJovialBitVal; };
20780
20781// Class: JovialTableType
20782template <> struct describe_field_t<SgJovialTableType,SgType*,&SgJovialTableType::p_base_type> {
20783 using parent = SgJovialTableType;
20784 using field_type = SgType*;
20785 static constexpr size_t position{0};
20786 static constexpr char const * const name{"base_type"};
20787 static constexpr char const * const typestr{"SgType*"};
20788 static constexpr bool traverse{false};
20789 static constexpr auto mbr_ptr{&SgJovialTableType::p_base_type};
20790 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20791 using bind = Desc<SgJovialTableType, SgType* SgJovialTableType::*, &SgJovialTableType::p_base_type>;
20792};
20793template <> struct describe_field_t<SgJovialTableType,SgExprListExp*,&SgJovialTableType::p_dim_info> {
20794 using parent = SgJovialTableType;
20795 using field_type = SgExprListExp*;
20796 static constexpr size_t position{1};
20797 static constexpr char const * const name{"dim_info"};
20798 static constexpr char const * const typestr{"SgExprListExp*"};
20799 static constexpr bool traverse{true};
20800 static constexpr auto mbr_ptr{&SgJovialTableType::p_dim_info};
20801 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20802 using bind = Desc<SgJovialTableType, SgExprListExp* SgJovialTableType::*, &SgJovialTableType::p_dim_info>;
20803};
20804template <> struct describe_field_t<SgJovialTableType,int,&SgJovialTableType::p_rank> {
20805 using parent = SgJovialTableType;
20806 using field_type = int;
20807 static constexpr size_t position{2};
20808 static constexpr char const * const name{"rank"};
20809 static constexpr char const * const typestr{"int"};
20810 static constexpr bool traverse{false};
20811 static constexpr auto mbr_ptr{&SgJovialTableType::p_rank};
20812 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20813 using bind = Desc<SgJovialTableType, int SgJovialTableType::*, &SgJovialTableType::p_rank>;
20814};
20815template <> struct describe_field_t<SgJovialTableType,SgJovialTableType::StructureSpecifier,&SgJovialTableType::p_structure_specifier> {
20816 using parent = SgJovialTableType;
20818 static constexpr size_t position{3};
20819 static constexpr char const * const name{"structure_specifier"};
20820 static constexpr char const * const typestr{"SgJovialTableType::StructureSpecifier"};
20821 static constexpr bool traverse{false};
20822 static constexpr auto mbr_ptr{&SgJovialTableType::p_structure_specifier};
20823 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20824 using bind = Desc<SgJovialTableType, SgJovialTableType::StructureSpecifier SgJovialTableType::*, &SgJovialTableType::p_structure_specifier>;
20825};
20826template <> struct describe_field_t<SgJovialTableType,unsigned int,&SgJovialTableType::p_bits_per_entry> {
20827 using parent = SgJovialTableType;
20828 using field_type = unsigned int;
20829 static constexpr size_t position{4};
20830 static constexpr char const * const name{"bits_per_entry"};
20831 static constexpr char const * const typestr{"unsigned int"};
20832 static constexpr bool traverse{false};
20833 static constexpr auto mbr_ptr{&SgJovialTableType::p_bits_per_entry};
20834 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20835 using bind = Desc<SgJovialTableType, unsigned int SgJovialTableType::*, &SgJovialTableType::p_bits_per_entry>;
20836};
20846template <> struct node_from_variant_t<494> { using type = SgJovialTableType; };
20847
20848// Class: JovialCompoolStatement
20849template <> struct describe_field_t<SgJovialCompoolStatement,SgName,&SgJovialCompoolStatement::p_name> {
20851 using field_type = SgName;
20852 static constexpr size_t position{0};
20853 static constexpr char const * const name{"name"};
20854 static constexpr char const * const typestr{"SgName"};
20855 static constexpr bool traverse{false};
20856 static constexpr auto mbr_ptr{&SgJovialCompoolStatement::p_name};
20857 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20858 using bind = Desc<SgJovialCompoolStatement, SgName SgJovialCompoolStatement::*, &SgJovialCompoolStatement::p_name>;
20859};
20863 static constexpr char const * const name{"JovialCompoolStatement"};
20864 static constexpr unsigned long variant{495};
20865 static constexpr bool concrete{true};
20866 using subclasses_t = mp::List<>;
20868};
20869template <> struct node_from_variant_t<495> { using type = SgJovialCompoolStatement; };
20870
20871// Class: JovialForThenStatement
20872template <> struct describe_field_t<SgJovialForThenStatement,SgExpression*,&SgJovialForThenStatement::p_initialization> {
20874 using field_type = SgExpression*;
20875 static constexpr size_t position{0};
20876 static constexpr char const * const name{"initialization"};
20877 static constexpr char const * const typestr{"SgExpression*"};
20878 static constexpr bool traverse{true};
20879 static constexpr auto mbr_ptr{&SgJovialForThenStatement::p_initialization};
20880 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20881 using bind = Desc<SgJovialForThenStatement, SgExpression* SgJovialForThenStatement::*, &SgJovialForThenStatement::p_initialization>;
20882};
20883template <> struct describe_field_t<SgJovialForThenStatement,SgExpression*,&SgJovialForThenStatement::p_while_expression> {
20885 using field_type = SgExpression*;
20886 static constexpr size_t position{1};
20887 static constexpr char const * const name{"while_expression"};
20888 static constexpr char const * const typestr{"SgExpression*"};
20889 static constexpr bool traverse{true};
20890 static constexpr auto mbr_ptr{&SgJovialForThenStatement::p_while_expression};
20891 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20892 using bind = Desc<SgJovialForThenStatement, SgExpression* SgJovialForThenStatement::*, &SgJovialForThenStatement::p_while_expression>;
20893};
20894template <> struct describe_field_t<SgJovialForThenStatement,SgExpression*,&SgJovialForThenStatement::p_by_or_then_expression> {
20896 using field_type = SgExpression*;
20897 static constexpr size_t position{2};
20898 static constexpr char const * const name{"by_or_then_expression"};
20899 static constexpr char const * const typestr{"SgExpression*"};
20900 static constexpr bool traverse{true};
20901 static constexpr auto mbr_ptr{&SgJovialForThenStatement::p_by_or_then_expression};
20902 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20903 using bind = Desc<SgJovialForThenStatement, SgExpression* SgJovialForThenStatement::*, &SgJovialForThenStatement::p_by_or_then_expression>;
20904};
20905template <> struct describe_field_t<SgJovialForThenStatement,SgBasicBlock*,&SgJovialForThenStatement::p_loop_body> {
20907 using field_type = SgBasicBlock*;
20908 static constexpr size_t position{3};
20909 static constexpr char const * const name{"loop_body"};
20910 static constexpr char const * const typestr{"SgBasicBlock*"};
20911 static constexpr bool traverse{true};
20912 static constexpr auto mbr_ptr{&SgJovialForThenStatement::p_loop_body};
20913 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20914 using bind = Desc<SgJovialForThenStatement, SgBasicBlock* SgJovialForThenStatement::*, &SgJovialForThenStatement::p_loop_body>;
20915};
20916template <> struct describe_field_t<SgJovialForThenStatement,SgJovialForThenStatement::loop_statement_type_enum,&SgJovialForThenStatement::p_loop_statement_type> {
20919 static constexpr size_t position{4};
20920 static constexpr char const * const name{"loop_statement_type"};
20921 static constexpr char const * const typestr{"SgJovialForThenStatement::loop_statement_type_enum"};
20922 static constexpr bool traverse{false};
20923 static constexpr auto mbr_ptr{&SgJovialForThenStatement::p_loop_statement_type};
20924 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20925 using bind = Desc<SgJovialForThenStatement, SgJovialForThenStatement::loop_statement_type_enum SgJovialForThenStatement::*, &SgJovialForThenStatement::p_loop_statement_type>;
20926};
20936template <> struct node_from_variant_t<496> { using type = SgJovialForThenStatement; };
20937
20938// Class: JovialDefineDeclaration
20939template <> struct describe_field_t<SgJovialDefineDeclaration,std::string,&SgJovialDefineDeclaration::p_define_string> {
20941 using field_type = std::string;
20942 static constexpr size_t position{0};
20943 static constexpr char const * const name{"define_string"};
20944 static constexpr char const * const typestr{"std::string"};
20945 static constexpr bool traverse{false};
20946 static constexpr auto mbr_ptr{&SgJovialDefineDeclaration::p_define_string};
20947 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20948 using bind = Desc<SgJovialDefineDeclaration, std::string SgJovialDefineDeclaration::*, &SgJovialDefineDeclaration::p_define_string>;
20949};
20953 static constexpr char const * const name{"JovialDefineDeclaration"};
20954 static constexpr unsigned long variant{497};
20955 static constexpr bool concrete{true};
20956 using subclasses_t = mp::List<>;
20958};
20959template <> struct node_from_variant_t<497> { using type = SgJovialDefineDeclaration; };
20960
20961// Class: JovialDirectiveStatement
20962template <> struct describe_field_t<SgJovialDirectiveStatement,std::string,&SgJovialDirectiveStatement::p_content_string> {
20964 using field_type = std::string;
20965 static constexpr size_t position{0};
20966 static constexpr char const * const name{"content_string"};
20967 static constexpr char const * const typestr{"std::string"};
20968 static constexpr bool traverse{false};
20969 static constexpr auto mbr_ptr{&SgJovialDirectiveStatement::p_content_string};
20970 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20971 using bind = Desc<SgJovialDirectiveStatement, std::string SgJovialDirectiveStatement::*, &SgJovialDirectiveStatement::p_content_string>;
20972};
20973template <> struct describe_field_t<SgJovialDirectiveStatement,SgJovialDirectiveStatement::directive_types,&SgJovialDirectiveStatement::p_directive_type> {
20976 static constexpr size_t position{1};
20977 static constexpr char const * const name{"directive_type"};
20978 static constexpr char const * const typestr{"SgJovialDirectiveStatement::directive_types"};
20979 static constexpr bool traverse{false};
20980 static constexpr auto mbr_ptr{&SgJovialDirectiveStatement::p_directive_type};
20981 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
20982 using bind = Desc<SgJovialDirectiveStatement, SgJovialDirectiveStatement::directive_types SgJovialDirectiveStatement::*, &SgJovialDirectiveStatement::p_directive_type>;
20983};
20987 static constexpr char const * const name{"JovialDirectiveStatement"};
20988 static constexpr unsigned long variant{498};
20989 static constexpr bool concrete{true};
20990 using subclasses_t = mp::List<>;
20992};
20993template <> struct node_from_variant_t<498> { using type = SgJovialDirectiveStatement; };
20994
20995// Class: JovialOverlayDeclaration
20996template <> struct describe_field_t<SgJovialOverlayDeclaration,SgExpression*,&SgJovialOverlayDeclaration::p_address> {
20998 using field_type = SgExpression*;
20999 static constexpr size_t position{0};
21000 static constexpr char const * const name{"address"};
21001 static constexpr char const * const typestr{"SgExpression*"};
21002 static constexpr bool traverse{true};
21003 static constexpr auto mbr_ptr{&SgJovialOverlayDeclaration::p_address};
21004 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21005 using bind = Desc<SgJovialOverlayDeclaration, SgExpression* SgJovialOverlayDeclaration::*, &SgJovialOverlayDeclaration::p_address>;
21006};
21007template <> struct describe_field_t<SgJovialOverlayDeclaration,SgExprListExp*,&SgJovialOverlayDeclaration::p_overlay> {
21009 using field_type = SgExprListExp*;
21010 static constexpr size_t position{1};
21011 static constexpr char const * const name{"overlay"};
21012 static constexpr char const * const typestr{"SgExprListExp*"};
21013 static constexpr bool traverse{true};
21014 static constexpr auto mbr_ptr{&SgJovialOverlayDeclaration::p_overlay};
21015 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21016 using bind = Desc<SgJovialOverlayDeclaration, SgExprListExp* SgJovialOverlayDeclaration::*, &SgJovialOverlayDeclaration::p_overlay>;
21017};
21021 static constexpr char const * const name{"JovialOverlayDeclaration"};
21022 static constexpr unsigned long variant{499};
21023 static constexpr bool concrete{true};
21024 using subclasses_t = mp::List<>;
21026};
21027template <> struct node_from_variant_t<499> { using type = SgJovialOverlayDeclaration; };
21028
21029// Class: JovialPresetPositionExp
21030template <> struct describe_field_t<SgJovialPresetPositionExp,SgExprListExp*,&SgJovialPresetPositionExp::p_indices> {
21032 using field_type = SgExprListExp*;
21033 static constexpr size_t position{0};
21034 static constexpr char const * const name{"indices"};
21035 static constexpr char const * const typestr{"SgExprListExp*"};
21036 static constexpr bool traverse{true};
21037 static constexpr auto mbr_ptr{&SgJovialPresetPositionExp::p_indices};
21038 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21039 using bind = Desc<SgJovialPresetPositionExp, SgExprListExp* SgJovialPresetPositionExp::*, &SgJovialPresetPositionExp::p_indices>;
21040};
21041template <> struct describe_field_t<SgJovialPresetPositionExp,SgExpression*,&SgJovialPresetPositionExp::p_value> {
21043 using field_type = SgExpression*;
21044 static constexpr size_t position{1};
21045 static constexpr char const * const name{"value"};
21046 static constexpr char const * const typestr{"SgExpression*"};
21047 static constexpr bool traverse{true};
21048 static constexpr auto mbr_ptr{&SgJovialPresetPositionExp::p_value};
21049 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21050 using bind = Desc<SgJovialPresetPositionExp, SgExpression* SgJovialPresetPositionExp::*, &SgJovialPresetPositionExp::p_value>;
21051};
21054 using base = SgExpression;
21055 static constexpr char const * const name{"JovialPresetPositionExp"};
21056 static constexpr unsigned long variant{500};
21057 static constexpr bool concrete{true};
21058 using subclasses_t = mp::List<>;
21060};
21061template <> struct node_from_variant_t<500> { using type = SgJovialPresetPositionExp; };
21062
21063// Class: JovialTablePresetExp
21064template <> struct describe_field_t<SgJovialTablePresetExp,SgExprListExp*,&SgJovialTablePresetExp::p_preset_list> {
21066 using field_type = SgExprListExp*;
21067 static constexpr size_t position{0};
21068 static constexpr char const * const name{"preset_list"};
21069 static constexpr char const * const typestr{"SgExprListExp*"};
21070 static constexpr bool traverse{true};
21071 static constexpr auto mbr_ptr{&SgJovialTablePresetExp::p_preset_list};
21072 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21073 using bind = Desc<SgJovialTablePresetExp, SgExprListExp* SgJovialTablePresetExp::*, &SgJovialTablePresetExp::p_preset_list>;
21074};
21077 using base = SgExpression;
21078 static constexpr char const * const name{"JovialTablePresetExp"};
21079 static constexpr unsigned long variant{501};
21080 static constexpr bool concrete{true};
21081 using subclasses_t = mp::List<>;
21083};
21084template <> struct node_from_variant_t<501> { using type = SgJovialTablePresetExp; };
21085
21086// Class: JovialTableStatement
21087template <> struct describe_field_t<SgJovialTableStatement,SgExpression*,&SgJovialTableStatement::p_table_entry_size> {
21089 using field_type = SgExpression*;
21090 static constexpr size_t position{0};
21091 static constexpr char const * const name{"table_entry_size"};
21092 static constexpr char const * const typestr{"SgExpression*"};
21093 static constexpr bool traverse{false};
21094 static constexpr auto mbr_ptr{&SgJovialTableStatement::p_table_entry_size};
21095 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21096 using bind = Desc<SgJovialTableStatement, SgExpression* SgJovialTableStatement::*, &SgJovialTableStatement::p_table_entry_size>;
21097};
21098template <> struct describe_field_t<SgJovialTableStatement,bool,&SgJovialTableStatement::p_has_table_entry_size> {
21100 using field_type = bool;
21101 static constexpr size_t position{1};
21102 static constexpr char const * const name{"has_table_entry_size"};
21103 static constexpr char const * const typestr{"bool"};
21104 static constexpr bool traverse{false};
21105 static constexpr auto mbr_ptr{&SgJovialTableStatement::p_has_table_entry_size};
21106 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21107 using bind = Desc<SgJovialTableStatement, bool SgJovialTableStatement::*, &SgJovialTableStatement::p_has_table_entry_size>;
21108};
21109template <> struct describe_field_t<SgJovialTableStatement,SgJovialTableStatement::WordsPerEntry,&SgJovialTableStatement::p_words_per_entry> {
21112 static constexpr size_t position{2};
21113 static constexpr char const * const name{"words_per_entry"};
21114 static constexpr char const * const typestr{"SgJovialTableStatement::WordsPerEntry"};
21115 static constexpr bool traverse{false};
21116 static constexpr auto mbr_ptr{&SgJovialTableStatement::p_words_per_entry};
21117 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21118 using bind = Desc<SgJovialTableStatement, SgJovialTableStatement::WordsPerEntry SgJovialTableStatement::*, &SgJovialTableStatement::p_words_per_entry>;
21119};
21120template <> struct describe_field_t<SgJovialTableStatement,std::string,&SgJovialTableStatement::p_like_table_name> {
21122 using field_type = std::string;
21123 static constexpr size_t position{3};
21124 static constexpr char const * const name{"like_table_name"};
21125 static constexpr char const * const typestr{"std::string"};
21126 static constexpr bool traverse{false};
21127 static constexpr auto mbr_ptr{&SgJovialTableStatement::p_like_table_name};
21128 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21129 using bind = Desc<SgJovialTableStatement, std::string SgJovialTableStatement::*, &SgJovialTableStatement::p_like_table_name>;
21130};
21131template <> struct describe_field_t<SgJovialTableStatement,bool,&SgJovialTableStatement::p_has_like_option> {
21133 using field_type = bool;
21134 static constexpr size_t position{4};
21135 static constexpr char const * const name{"has_like_option"};
21136 static constexpr char const * const typestr{"bool"};
21137 static constexpr bool traverse{false};
21138 static constexpr auto mbr_ptr{&SgJovialTableStatement::p_has_like_option};
21139 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21140 using bind = Desc<SgJovialTableStatement, bool SgJovialTableStatement::*, &SgJovialTableStatement::p_has_like_option>;
21141};
21151template <> struct node_from_variant_t<502> { using type = SgJovialTableStatement; };
21152
21153// Class: KeyDatumPair
21154template <> struct describe_field_t<SgKeyDatumPair,SgExpression*,&SgKeyDatumPair::p_key> {
21155 using parent = SgKeyDatumPair;
21156 using field_type = SgExpression*;
21157 static constexpr size_t position{0};
21158 static constexpr char const * const name{"key"};
21159 static constexpr char const * const typestr{"SgExpression*"};
21160 static constexpr bool traverse{true};
21161 static constexpr auto mbr_ptr{&SgKeyDatumPair::p_key};
21162 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21163 using bind = Desc<SgKeyDatumPair, SgExpression* SgKeyDatumPair::*, &SgKeyDatumPair::p_key>;
21164};
21165template <> struct describe_field_t<SgKeyDatumPair,SgExpression*,&SgKeyDatumPair::p_datum> {
21166 using parent = SgKeyDatumPair;
21167 using field_type = SgExpression*;
21168 static constexpr size_t position{1};
21169 static constexpr char const * const name{"datum"};
21170 static constexpr char const * const typestr{"SgExpression*"};
21171 static constexpr bool traverse{true};
21172 static constexpr auto mbr_ptr{&SgKeyDatumPair::p_datum};
21173 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21174 using bind = Desc<SgKeyDatumPair, SgExpression* SgKeyDatumPair::*, &SgKeyDatumPair::p_datum>;
21175};
21176template <> struct describe_node_t<SgKeyDatumPair> {
21177 using node = SgKeyDatumPair;
21178 using base = SgExpression;
21179 static constexpr char const * const name{"KeyDatumPair"};
21180 static constexpr unsigned long variant{503};
21181 static constexpr bool concrete{true};
21182 using subclasses_t = mp::List<>;
21184};
21185template <> struct node_from_variant_t<503> { using type = SgKeyDatumPair; };
21186
21187// Class: CudaKernelExecConfig
21188template <> struct describe_field_t<SgCudaKernelExecConfig,SgExpression*,&SgCudaKernelExecConfig::p_grid> {
21190 using field_type = SgExpression*;
21191 static constexpr size_t position{0};
21192 static constexpr char const * const name{"grid"};
21193 static constexpr char const * const typestr{"SgExpression*"};
21194 static constexpr bool traverse{true};
21195 static constexpr auto mbr_ptr{&SgCudaKernelExecConfig::p_grid};
21196 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21197 using bind = Desc<SgCudaKernelExecConfig, SgExpression* SgCudaKernelExecConfig::*, &SgCudaKernelExecConfig::p_grid>;
21198};
21199template <> struct describe_field_t<SgCudaKernelExecConfig,SgExpression*,&SgCudaKernelExecConfig::p_blocks> {
21201 using field_type = SgExpression*;
21202 static constexpr size_t position{1};
21203 static constexpr char const * const name{"blocks"};
21204 static constexpr char const * const typestr{"SgExpression*"};
21205 static constexpr bool traverse{true};
21206 static constexpr auto mbr_ptr{&SgCudaKernelExecConfig::p_blocks};
21207 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21208 using bind = Desc<SgCudaKernelExecConfig, SgExpression* SgCudaKernelExecConfig::*, &SgCudaKernelExecConfig::p_blocks>;
21209};
21210template <> struct describe_field_t<SgCudaKernelExecConfig,SgExpression*,&SgCudaKernelExecConfig::p_shared> {
21212 using field_type = SgExpression*;
21213 static constexpr size_t position{2};
21214 static constexpr char const * const name{"shared"};
21215 static constexpr char const * const typestr{"SgExpression*"};
21216 static constexpr bool traverse{true};
21217 static constexpr auto mbr_ptr{&SgCudaKernelExecConfig::p_shared};
21218 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21219 using bind = Desc<SgCudaKernelExecConfig, SgExpression* SgCudaKernelExecConfig::*, &SgCudaKernelExecConfig::p_shared>;
21220};
21221template <> struct describe_field_t<SgCudaKernelExecConfig,SgExpression*,&SgCudaKernelExecConfig::p_stream> {
21223 using field_type = SgExpression*;
21224 static constexpr size_t position{3};
21225 static constexpr char const * const name{"stream"};
21226 static constexpr char const * const typestr{"SgExpression*"};
21227 static constexpr bool traverse{true};
21228 static constexpr auto mbr_ptr{&SgCudaKernelExecConfig::p_stream};
21229 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21230 using bind = Desc<SgCudaKernelExecConfig, SgExpression* SgCudaKernelExecConfig::*, &SgCudaKernelExecConfig::p_stream>;
21231};
21241template <> struct node_from_variant_t<504> { using type = SgCudaKernelExecConfig; };
21242
21243// Class: CudaKernelCallExp
21244template <> struct describe_field_t<SgCudaKernelCallExp,SgCudaKernelExecConfig*,&SgCudaKernelCallExp::p_exec_config> {
21247 static constexpr size_t position{0};
21248 static constexpr char const * const name{"exec_config"};
21249 static constexpr char const * const typestr{"SgCudaKernelExecConfig*"};
21250 static constexpr bool traverse{true};
21251 static constexpr auto mbr_ptr{&SgCudaKernelCallExp::p_exec_config};
21252 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21253 using bind = Desc<SgCudaKernelCallExp, SgCudaKernelExecConfig* SgCudaKernelCallExp::*, &SgCudaKernelCallExp::p_exec_config>;
21254};
21256 using node = SgCudaKernelCallExp;
21257 using base = SgFunctionCallExp;
21258 static constexpr char const * const name{"CudaKernelCallExp"};
21259 static constexpr unsigned long variant{505};
21260 static constexpr bool concrete{true};
21261 using subclasses_t = mp::List<>;
21263};
21264template <> struct node_from_variant_t<505> { using type = SgCudaKernelCallExp; };
21265
21266// Class: LabelRefExp
21267template <> struct describe_field_t<SgLabelRefExp,SgLabelSymbol*,&SgLabelRefExp::p_symbol> {
21268 using parent = SgLabelRefExp;
21269 using field_type = SgLabelSymbol*;
21270 static constexpr size_t position{0};
21271 static constexpr char const * const name{"symbol"};
21272 static constexpr char const * const typestr{"SgLabelSymbol*"};
21273 static constexpr bool traverse{false};
21274 static constexpr auto mbr_ptr{&SgLabelRefExp::p_symbol};
21275 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21276 using bind = Desc<SgLabelRefExp, SgLabelSymbol* SgLabelRefExp::*, &SgLabelRefExp::p_symbol>;
21277};
21278template <> struct describe_node_t<SgLabelRefExp> {
21279 using node = SgLabelRefExp;
21280 using base = SgReferenceExp;
21281 static constexpr char const * const name{"LabelRefExp"};
21282 static constexpr unsigned long variant{506};
21283 static constexpr bool concrete{true};
21284 using subclasses_t = mp::List<>;
21286};
21287template <> struct node_from_variant_t<506> { using type = SgLabelRefExp; };
21288
21289// Class: LabelStatement
21291 using parent = SgLabelStatement;
21292 using field_type = SgName;
21293 static constexpr size_t position{0};
21294 static constexpr char const * const name{"label"};
21295 static constexpr char const * const typestr{"SgName"};
21296 static constexpr bool traverse{false};
21297 static constexpr auto mbr_ptr{&SgLabelStatement::p_label};
21298 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21299 using bind = Desc<SgLabelStatement, SgName SgLabelStatement::*, &SgLabelStatement::p_label>;
21300};
21301template <> struct describe_field_t<SgLabelStatement,SgScopeStatement*,&SgLabelStatement::p_scope> {
21302 using parent = SgLabelStatement;
21304 static constexpr size_t position{1};
21305 static constexpr char const * const name{"scope"};
21306 static constexpr char const * const typestr{"SgScopeStatement*"};
21307 static constexpr bool traverse{false};
21308 static constexpr auto mbr_ptr{&SgLabelStatement::p_scope};
21309 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21310 using bind = Desc<SgLabelStatement, SgScopeStatement* SgLabelStatement::*, &SgLabelStatement::p_scope>;
21311};
21312template <> struct describe_field_t<SgLabelStatement,SgStatement*,&SgLabelStatement::p_statement> {
21313 using parent = SgLabelStatement;
21314 using field_type = SgStatement*;
21315 static constexpr size_t position{2};
21316 static constexpr char const * const name{"statement"};
21317 static constexpr char const * const typestr{"SgStatement*"};
21318 static constexpr bool traverse{true};
21319 static constexpr auto mbr_ptr{&SgLabelStatement::p_statement};
21320 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21321 using bind = Desc<SgLabelStatement, SgStatement* SgLabelStatement::*, &SgLabelStatement::p_statement>;
21322};
21323template <> struct describe_field_t<SgLabelStatement,SgLabelStatement::label_type_enum,&SgLabelStatement::p_label_type> {
21324 using parent = SgLabelStatement;
21326 static constexpr size_t position{3};
21327 static constexpr char const * const name{"label_type"};
21328 static constexpr char const * const typestr{"SgLabelStatement::label_type_enum"};
21329 static constexpr bool traverse{false};
21330 static constexpr auto mbr_ptr{&SgLabelStatement::p_label_type};
21331 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21332 using bind = Desc<SgLabelStatement, SgLabelStatement::label_type_enum SgLabelStatement::*, &SgLabelStatement::p_label_type>;
21333};
21334template <> struct describe_field_t<SgLabelStatement,bool,&SgLabelStatement::p_gnu_extension_unused> {
21335 using parent = SgLabelStatement;
21336 using field_type = bool;
21337 static constexpr size_t position{4};
21338 static constexpr char const * const name{"gnu_extension_unused"};
21339 static constexpr char const * const typestr{"bool"};
21340 static constexpr bool traverse{false};
21341 static constexpr auto mbr_ptr{&SgLabelStatement::p_gnu_extension_unused};
21342 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21343 using bind = Desc<SgLabelStatement, bool SgLabelStatement::*, &SgLabelStatement::p_gnu_extension_unused>;
21344};
21354template <> struct node_from_variant_t<507> { using type = SgLabelStatement; };
21355
21356// Class: JavaLabelStatement
21357template <> struct describe_field_t<SgJavaLabelStatement,SgName,&SgJavaLabelStatement::p_label> {
21359 using field_type = SgName;
21360 static constexpr size_t position{0};
21361 static constexpr char const * const name{"label"};
21362 static constexpr char const * const typestr{"SgName"};
21363 static constexpr bool traverse{false};
21364 static constexpr auto mbr_ptr{&SgJavaLabelStatement::p_label};
21365 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21366 using bind = Desc<SgJavaLabelStatement, SgName SgJavaLabelStatement::*, &SgJavaLabelStatement::p_label>;
21367};
21368template <> struct describe_field_t<SgJavaLabelStatement,SgStatement*,&SgJavaLabelStatement::p_statement> {
21370 using field_type = SgStatement*;
21371 static constexpr size_t position{1};
21372 static constexpr char const * const name{"statement"};
21373 static constexpr char const * const typestr{"SgStatement*"};
21374 static constexpr bool traverse{true};
21375 static constexpr auto mbr_ptr{&SgJavaLabelStatement::p_statement};
21376 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21377 using bind = Desc<SgJavaLabelStatement, SgStatement* SgJavaLabelStatement::*, &SgJavaLabelStatement::p_statement>;
21378};
21380 using node = SgJavaLabelStatement;
21381 using base = SgScopeStatement;
21382 static constexpr char const * const name{"JavaLabelStatement"};
21383 static constexpr unsigned long variant{508};
21384 static constexpr bool concrete{true};
21385 using subclasses_t = mp::List<>;
21387};
21388template <> struct node_from_variant_t<508> { using type = SgJavaLabelStatement; };
21389
21390// Class: LabelSymbol
21391template <> struct describe_field_t<SgLabelSymbol,SgLabelStatement*,&SgLabelSymbol::p_declaration> {
21392 using parent = SgLabelSymbol;
21394 static constexpr size_t position{0};
21395 static constexpr char const * const name{"declaration"};
21396 static constexpr char const * const typestr{"SgLabelStatement*"};
21397 static constexpr bool traverse{true};
21398 static constexpr auto mbr_ptr{&SgLabelSymbol::p_declaration};
21399 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21400 using bind = Desc<SgLabelSymbol, SgLabelStatement* SgLabelSymbol::*, &SgLabelSymbol::p_declaration>;
21401};
21402template <> struct describe_field_t<SgLabelSymbol,SgStatement*,&SgLabelSymbol::p_fortran_statement> {
21403 using parent = SgLabelSymbol;
21404 using field_type = SgStatement*;
21405 static constexpr size_t position{1};
21406 static constexpr char const * const name{"fortran_statement"};
21407 static constexpr char const * const typestr{"SgStatement*"};
21408 static constexpr bool traverse{false};
21409 static constexpr auto mbr_ptr{&SgLabelSymbol::p_fortran_statement};
21410 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21411 using bind = Desc<SgLabelSymbol, SgStatement* SgLabelSymbol::*, &SgLabelSymbol::p_fortran_statement>;
21412};
21413template <> struct describe_field_t<SgLabelSymbol,SgInitializedName*,&SgLabelSymbol::p_fortran_alternate_return_parameter> {
21414 using parent = SgLabelSymbol;
21416 static constexpr size_t position{2};
21417 static constexpr char const * const name{"fortran_alternate_return_parameter"};
21418 static constexpr char const * const typestr{"SgInitializedName*"};
21419 static constexpr bool traverse{false};
21420 static constexpr auto mbr_ptr{&SgLabelSymbol::p_fortran_alternate_return_parameter};
21421 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21422 using bind = Desc<SgLabelSymbol, SgInitializedName* SgLabelSymbol::*, &SgLabelSymbol::p_fortran_alternate_return_parameter>;
21423};
21424template <> struct describe_field_t<SgLabelSymbol,int,&SgLabelSymbol::p_numeric_label_value> {
21425 using parent = SgLabelSymbol;
21426 using field_type = int;
21427 static constexpr size_t position{3};
21428 static constexpr char const * const name{"numeric_label_value"};
21429 static constexpr char const * const typestr{"int"};
21430 static constexpr bool traverse{false};
21431 static constexpr auto mbr_ptr{&SgLabelSymbol::p_numeric_label_value};
21432 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21433 using bind = Desc<SgLabelSymbol, int SgLabelSymbol::*, &SgLabelSymbol::p_numeric_label_value>;
21434};
21435template <> struct describe_field_t<SgLabelSymbol,SgLabelSymbol::label_type_enum,&SgLabelSymbol::p_label_type> {
21436 using parent = SgLabelSymbol;
21438 static constexpr size_t position{4};
21439 static constexpr char const * const name{"label_type"};
21440 static constexpr char const * const typestr{"SgLabelSymbol::label_type_enum"};
21441 static constexpr bool traverse{false};
21442 static constexpr auto mbr_ptr{&SgLabelSymbol::p_label_type};
21443 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21444 using bind = Desc<SgLabelSymbol, SgLabelSymbol::label_type_enum SgLabelSymbol::*, &SgLabelSymbol::p_label_type>;
21445};
21455template <> struct node_from_variant_t<509> { using type = SgLabelSymbol; };
21456
21457// Class: JavaLabelSymbol
21458template <> struct describe_field_t<SgJavaLabelSymbol,SgJavaLabelStatement*,&SgJavaLabelSymbol::p_declaration> {
21459 using parent = SgJavaLabelSymbol;
21461 static constexpr size_t position{0};
21462 static constexpr char const * const name{"declaration"};
21463 static constexpr char const * const typestr{"SgJavaLabelStatement*"};
21464 static constexpr bool traverse{true};
21465 static constexpr auto mbr_ptr{&SgJavaLabelSymbol::p_declaration};
21466 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21467 using bind = Desc<SgJavaLabelSymbol, SgJavaLabelStatement* SgJavaLabelSymbol::*, &SgJavaLabelSymbol::p_declaration>;
21468};
21470 using node = SgJavaLabelSymbol;
21471 using base = SgSymbol;
21472 static constexpr char const * const name{"JavaLabelSymbol"};
21473 static constexpr unsigned long variant{510};
21474 static constexpr bool concrete{true};
21475 using subclasses_t = mp::List<>;
21477};
21478template <> struct node_from_variant_t<510> { using type = SgJavaLabelSymbol; };
21479
21480// Class: LambdaCapture
21481template <> struct describe_field_t<SgLambdaCapture,SgExpression*,&SgLambdaCapture::p_capture_variable> {
21482 using parent = SgLambdaCapture;
21483 using field_type = SgExpression*;
21484 static constexpr size_t position{0};
21485 static constexpr char const * const name{"capture_variable"};
21486 static constexpr char const * const typestr{"SgExpression*"};
21487 static constexpr bool traverse{true};
21488 static constexpr auto mbr_ptr{&SgLambdaCapture::p_capture_variable};
21489 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21490 using bind = Desc<SgLambdaCapture, SgExpression* SgLambdaCapture::*, &SgLambdaCapture::p_capture_variable>;
21491};
21492template <> struct describe_field_t<SgLambdaCapture,SgExpression*,&SgLambdaCapture::p_source_closure_variable> {
21493 using parent = SgLambdaCapture;
21494 using field_type = SgExpression*;
21495 static constexpr size_t position{1};
21496 static constexpr char const * const name{"source_closure_variable"};
21497 static constexpr char const * const typestr{"SgExpression*"};
21498 static constexpr bool traverse{true};
21499 static constexpr auto mbr_ptr{&SgLambdaCapture::p_source_closure_variable};
21500 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21501 using bind = Desc<SgLambdaCapture, SgExpression* SgLambdaCapture::*, &SgLambdaCapture::p_source_closure_variable>;
21502};
21503template <> struct describe_field_t<SgLambdaCapture,SgExpression*,&SgLambdaCapture::p_closure_variable> {
21504 using parent = SgLambdaCapture;
21505 using field_type = SgExpression*;
21506 static constexpr size_t position{2};
21507 static constexpr char const * const name{"closure_variable"};
21508 static constexpr char const * const typestr{"SgExpression*"};
21509 static constexpr bool traverse{true};
21510 static constexpr auto mbr_ptr{&SgLambdaCapture::p_closure_variable};
21511 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21512 using bind = Desc<SgLambdaCapture, SgExpression* SgLambdaCapture::*, &SgLambdaCapture::p_closure_variable>;
21513};
21514template <> struct describe_field_t<SgLambdaCapture,bool,&SgLambdaCapture::p_capture_by_reference> {
21515 using parent = SgLambdaCapture;
21516 using field_type = bool;
21517 static constexpr size_t position{3};
21518 static constexpr char const * const name{"capture_by_reference"};
21519 static constexpr char const * const typestr{"bool"};
21520 static constexpr bool traverse{false};
21521 static constexpr auto mbr_ptr{&SgLambdaCapture::p_capture_by_reference};
21522 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21523 using bind = Desc<SgLambdaCapture, bool SgLambdaCapture::*, &SgLambdaCapture::p_capture_by_reference>;
21524};
21525template <> struct describe_field_t<SgLambdaCapture,bool,&SgLambdaCapture::p_implicit> {
21526 using parent = SgLambdaCapture;
21527 using field_type = bool;
21528 static constexpr size_t position{4};
21529 static constexpr char const * const name{"implicit"};
21530 static constexpr char const * const typestr{"bool"};
21531 static constexpr bool traverse{false};
21532 static constexpr auto mbr_ptr{&SgLambdaCapture::p_implicit};
21533 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21534 using bind = Desc<SgLambdaCapture, bool SgLambdaCapture::*, &SgLambdaCapture::p_implicit>;
21535};
21536template <> struct describe_field_t<SgLambdaCapture,bool,&SgLambdaCapture::p_pack_expansion> {
21537 using parent = SgLambdaCapture;
21538 using field_type = bool;
21539 static constexpr size_t position{5};
21540 static constexpr char const * const name{"pack_expansion"};
21541 static constexpr char const * const typestr{"bool"};
21542 static constexpr bool traverse{false};
21543 static constexpr auto mbr_ptr{&SgLambdaCapture::p_pack_expansion};
21544 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21545 using bind = Desc<SgLambdaCapture, bool SgLambdaCapture::*, &SgLambdaCapture::p_pack_expansion>;
21546};
21556template <> struct node_from_variant_t<511> { using type = SgLambdaCapture; };
21557
21558// Class: LambdaCaptureList
21559template <> struct describe_field_t<SgLambdaCaptureList,SgLambdaCapturePtrList,&SgLambdaCaptureList::p_capture_list> {
21561 using field_type = SgLambdaCapturePtrList;
21562 static constexpr size_t position{0};
21563 static constexpr char const * const name{"capture_list"};
21564 static constexpr char const * const typestr{"SgLambdaCapturePtrList"};
21565 static constexpr bool traverse{true};
21566 static constexpr auto mbr_ptr{&SgLambdaCaptureList::p_capture_list};
21567 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21568 using bind = Desc<SgLambdaCaptureList, SgLambdaCapturePtrList SgLambdaCaptureList::*, &SgLambdaCaptureList::p_capture_list>;
21569};
21571 using node = SgLambdaCaptureList;
21572 using base = SgLocatedNodeSupport;
21573 static constexpr char const * const name{"LambdaCaptureList"};
21574 static constexpr unsigned long variant{512};
21575 static constexpr bool concrete{true};
21576 using subclasses_t = mp::List<>;
21578};
21579template <> struct node_from_variant_t<512> { using type = SgLambdaCaptureList; };
21580
21581// Class: LambdaExp
21582template <> struct describe_field_t<SgLambdaExp,SgLambdaCaptureList*,&SgLambdaExp::p_lambda_capture_list> {
21583 using parent = SgLambdaExp;
21585 static constexpr size_t position{0};
21586 static constexpr char const * const name{"lambda_capture_list"};
21587 static constexpr char const * const typestr{"SgLambdaCaptureList*"};
21588 static constexpr bool traverse{true};
21589 static constexpr auto mbr_ptr{&SgLambdaExp::p_lambda_capture_list};
21590 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21591 using bind = Desc<SgLambdaExp, SgLambdaCaptureList* SgLambdaExp::*, &SgLambdaExp::p_lambda_capture_list>;
21592};
21593template <> struct describe_field_t<SgLambdaExp,SgClassDeclaration*,&SgLambdaExp::p_lambda_closure_class> {
21594 using parent = SgLambdaExp;
21596 static constexpr size_t position{1};
21597 static constexpr char const * const name{"lambda_closure_class"};
21598 static constexpr char const * const typestr{"SgClassDeclaration*"};
21599 static constexpr bool traverse{true};
21600 static constexpr auto mbr_ptr{&SgLambdaExp::p_lambda_closure_class};
21601 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21602 using bind = Desc<SgLambdaExp, SgClassDeclaration* SgLambdaExp::*, &SgLambdaExp::p_lambda_closure_class>;
21603};
21604template <> struct describe_field_t<SgLambdaExp,SgFunctionDeclaration*,&SgLambdaExp::p_lambda_function> {
21605 using parent = SgLambdaExp;
21607 static constexpr size_t position{2};
21608 static constexpr char const * const name{"lambda_function"};
21609 static constexpr char const * const typestr{"SgFunctionDeclaration*"};
21610 static constexpr bool traverse{true};
21611 static constexpr auto mbr_ptr{&SgLambdaExp::p_lambda_function};
21612 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21613 using bind = Desc<SgLambdaExp, SgFunctionDeclaration* SgLambdaExp::*, &SgLambdaExp::p_lambda_function>;
21614};
21615template <> struct describe_field_t<SgLambdaExp,bool,&SgLambdaExp::p_is_mutable> {
21616 using parent = SgLambdaExp;
21617 using field_type = bool;
21618 static constexpr size_t position{3};
21619 static constexpr char const * const name{"is_mutable"};
21620 static constexpr char const * const typestr{"bool"};
21621 static constexpr bool traverse{false};
21622 static constexpr auto mbr_ptr{&SgLambdaExp::p_is_mutable};
21623 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21624 using bind = Desc<SgLambdaExp, bool SgLambdaExp::*, &SgLambdaExp::p_is_mutable>;
21625};
21626template <> struct describe_field_t<SgLambdaExp,bool,&SgLambdaExp::p_capture_default> {
21627 using parent = SgLambdaExp;
21628 using field_type = bool;
21629 static constexpr size_t position{4};
21630 static constexpr char const * const name{"capture_default"};
21631 static constexpr char const * const typestr{"bool"};
21632 static constexpr bool traverse{false};
21633 static constexpr auto mbr_ptr{&SgLambdaExp::p_capture_default};
21634 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21635 using bind = Desc<SgLambdaExp, bool SgLambdaExp::*, &SgLambdaExp::p_capture_default>;
21636};
21637template <> struct describe_field_t<SgLambdaExp,bool,&SgLambdaExp::p_default_is_by_reference> {
21638 using parent = SgLambdaExp;
21639 using field_type = bool;
21640 static constexpr size_t position{5};
21641 static constexpr char const * const name{"default_is_by_reference"};
21642 static constexpr char const * const typestr{"bool"};
21643 static constexpr bool traverse{false};
21644 static constexpr auto mbr_ptr{&SgLambdaExp::p_default_is_by_reference};
21645 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21646 using bind = Desc<SgLambdaExp, bool SgLambdaExp::*, &SgLambdaExp::p_default_is_by_reference>;
21647};
21648template <> struct describe_field_t<SgLambdaExp,bool,&SgLambdaExp::p_explicit_return_type> {
21649 using parent = SgLambdaExp;
21650 using field_type = bool;
21651 static constexpr size_t position{6};
21652 static constexpr char const * const name{"explicit_return_type"};
21653 static constexpr char const * const typestr{"bool"};
21654 static constexpr bool traverse{false};
21655 static constexpr auto mbr_ptr{&SgLambdaExp::p_explicit_return_type};
21656 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21657 using bind = Desc<SgLambdaExp, bool SgLambdaExp::*, &SgLambdaExp::p_explicit_return_type>;
21658};
21659template <> struct describe_field_t<SgLambdaExp,bool,&SgLambdaExp::p_has_parameter_decl> {
21660 using parent = SgLambdaExp;
21661 using field_type = bool;
21662 static constexpr size_t position{7};
21663 static constexpr char const * const name{"has_parameter_decl"};
21664 static constexpr char const * const typestr{"bool"};
21665 static constexpr bool traverse{false};
21666 static constexpr auto mbr_ptr{&SgLambdaExp::p_has_parameter_decl};
21667 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21668 using bind = Desc<SgLambdaExp, bool SgLambdaExp::*, &SgLambdaExp::p_has_parameter_decl>;
21669};
21670template <> struct describe_field_t<SgLambdaExp,bool,&SgLambdaExp::p_is_device> {
21671 using parent = SgLambdaExp;
21672 using field_type = bool;
21673 static constexpr size_t position{8};
21674 static constexpr char const * const name{"is_device"};
21675 static constexpr char const * const typestr{"bool"};
21676 static constexpr bool traverse{false};
21677 static constexpr auto mbr_ptr{&SgLambdaExp::p_is_device};
21678 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21679 using bind = Desc<SgLambdaExp, bool SgLambdaExp::*, &SgLambdaExp::p_is_device>;
21680};
21690template <> struct node_from_variant_t<513> { using type = SgLambdaExp; };
21691
21692// Class: LambdaRefExp
21694 using parent = SgLambdaRefExp;
21696 static constexpr size_t position{0};
21697 static constexpr char const * const name{"functionDeclaration"};
21698 static constexpr char const * const typestr{"SgFunctionDeclaration*"};
21699 static constexpr bool traverse{true};
21700 static constexpr auto mbr_ptr{&SgLambdaRefExp::p_functionDeclaration};
21701 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21702 using bind = Desc<SgLambdaRefExp, SgFunctionDeclaration* SgLambdaRefExp::*, &SgLambdaRefExp::p_functionDeclaration>;
21703};
21704template <> struct describe_node_t<SgLambdaRefExp> {
21705 using node = SgLambdaRefExp;
21706 using base = SgExpression;
21707 static constexpr char const * const name{"LambdaRefExp"};
21708 static constexpr unsigned long variant{514};
21709 static constexpr bool concrete{true};
21710 using subclasses_t = mp::List<>;
21712};
21713template <> struct node_from_variant_t<514> { using type = SgLambdaRefExp; };
21714
21715// Class: LeftDivideOp
21716template <> struct describe_node_t<SgLeftDivideOp> {
21717 using node = SgLeftDivideOp;
21718 using base = SgBinaryOp;
21719 static constexpr char const * const name{"LeftDivideOp"};
21720 static constexpr unsigned long variant{515};
21721 static constexpr bool concrete{true};
21722 using subclasses_t = mp::List<>;
21723 using fields_t = mp::List<>;
21724};
21725template <> struct node_from_variant_t<515> { using type = SgLeftDivideOp; };
21726
21727// Class: LessOrEqualOp
21729 using node = SgLessOrEqualOp;
21730 using base = SgBinaryOp;
21731 static constexpr char const * const name{"LessOrEqualOp"};
21732 static constexpr unsigned long variant{516};
21733 static constexpr bool concrete{true};
21734 using subclasses_t = mp::List<>;
21735 using fields_t = mp::List<>;
21736};
21737template <> struct node_from_variant_t<516> { using type = SgLessOrEqualOp; };
21738
21739// Class: LessThanOp
21740template <> struct describe_node_t<SgLessThanOp> {
21741 using node = SgLessThanOp;
21742 using base = SgBinaryOp;
21743 static constexpr char const * const name{"LessThanOp"};
21744 static constexpr unsigned long variant{517};
21745 static constexpr bool concrete{true};
21746 using subclasses_t = mp::List<>;
21747 using fields_t = mp::List<>;
21748};
21749template <> struct node_from_variant_t<517> { using type = SgLessThanOp; };
21750
21751// Class: LineDirectiveStatement
21755 static constexpr char const * const name{"LineDirectiveStatement"};
21756 static constexpr unsigned long variant{518};
21757 static constexpr bool concrete{true};
21758 using subclasses_t = mp::List<>;
21759 using fields_t = mp::List<>;
21760};
21761template <> struct node_from_variant_t<518> { using type = SgLineDirectiveStatement; };
21762
21763// Class: LinemarkerDirectiveStatement
21764template <> struct describe_field_t<SgLinemarkerDirectiveStatement,int,&SgLinemarkerDirectiveStatement::p_linenumber> {
21766 using field_type = int;
21767 static constexpr size_t position{0};
21768 static constexpr char const * const name{"linenumber"};
21769 static constexpr char const * const typestr{"int"};
21770 static constexpr bool traverse{false};
21771 static constexpr auto mbr_ptr{&SgLinemarkerDirectiveStatement::p_linenumber};
21772 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21773 using bind = Desc<SgLinemarkerDirectiveStatement, int SgLinemarkerDirectiveStatement::*, &SgLinemarkerDirectiveStatement::p_linenumber>;
21774};
21775template <> struct describe_field_t<SgLinemarkerDirectiveStatement,std::string,&SgLinemarkerDirectiveStatement::p_filename> {
21777 using field_type = std::string;
21778 static constexpr size_t position{1};
21779 static constexpr char const * const name{"filename"};
21780 static constexpr char const * const typestr{"std::string"};
21781 static constexpr bool traverse{false};
21782 static constexpr auto mbr_ptr{&SgLinemarkerDirectiveStatement::p_filename};
21783 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21784 using bind = Desc<SgLinemarkerDirectiveStatement, std::string SgLinemarkerDirectiveStatement::*, &SgLinemarkerDirectiveStatement::p_filename>;
21785};
21786template <> struct describe_field_t<SgLinemarkerDirectiveStatement,SgUnsignedCharList,&SgLinemarkerDirectiveStatement::p_flaglist> {
21788 using field_type = SgUnsignedCharList;
21789 static constexpr size_t position{2};
21790 static constexpr char const * const name{"flaglist"};
21791 static constexpr char const * const typestr{"SgUnsignedCharList"};
21792 static constexpr bool traverse{false};
21793 static constexpr auto mbr_ptr{&SgLinemarkerDirectiveStatement::p_flaglist};
21794 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21795 using bind = Desc<SgLinemarkerDirectiveStatement, SgUnsignedCharList SgLinemarkerDirectiveStatement::*, &SgLinemarkerDirectiveStatement::p_flaglist>;
21796};
21806template <> struct node_from_variant_t<519> { using type = SgLinemarkerDirectiveStatement; };
21807
21808// Class: LinkageModifier
21809template <> struct describe_field_t<SgLinkageModifier,SgLinkageModifier::linkage_modifier_enum,&SgLinkageModifier::p_modifier> {
21810 using parent = SgLinkageModifier;
21812 static constexpr size_t position{0};
21813 static constexpr char const * const name{"modifier"};
21814 static constexpr char const * const typestr{"SgLinkageModifier::linkage_modifier_enum"};
21815 static constexpr bool traverse{false};
21816 static constexpr auto mbr_ptr{&SgLinkageModifier::p_modifier};
21817 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21818 using bind = Desc<SgLinkageModifier, SgLinkageModifier::linkage_modifier_enum SgLinkageModifier::*, &SgLinkageModifier::p_modifier>;
21819};
21821 using node = SgLinkageModifier;
21822 using base = SgModifier;
21823 static constexpr char const * const name{"LinkageModifier"};
21824 static constexpr unsigned long variant{520};
21825 static constexpr bool concrete{true};
21826 using subclasses_t = mp::List<>;
21828};
21829template <> struct node_from_variant_t<520> { using type = SgLinkageModifier; };
21830
21831// Class: ListComprehension
21832template <> struct describe_field_t<SgListComprehension,SgExpression*,&SgListComprehension::p_element> {
21834 using field_type = SgExpression*;
21835 static constexpr size_t position{0};
21836 static constexpr char const * const name{"element"};
21837 static constexpr char const * const typestr{"SgExpression*"};
21838 static constexpr bool traverse{true};
21839 static constexpr auto mbr_ptr{&SgListComprehension::p_element};
21840 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21841 using bind = Desc<SgListComprehension, SgExpression* SgListComprehension::*, &SgListComprehension::p_element>;
21842};
21843template <> struct describe_field_t<SgListComprehension,SgExprListExp*,&SgListComprehension::p_generators> {
21845 using field_type = SgExprListExp*;
21846 static constexpr size_t position{1};
21847 static constexpr char const * const name{"generators"};
21848 static constexpr char const * const typestr{"SgExprListExp*"};
21849 static constexpr bool traverse{true};
21850 static constexpr auto mbr_ptr{&SgListComprehension::p_generators};
21851 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21852 using bind = Desc<SgListComprehension, SgExprListExp* SgListComprehension::*, &SgListComprehension::p_generators>;
21853};
21855 using node = SgListComprehension;
21856 using base = SgExpression;
21857 static constexpr char const * const name{"ListComprehension"};
21858 static constexpr unsigned long variant{521};
21859 static constexpr bool concrete{true};
21860 using subclasses_t = mp::List<>;
21862};
21863template <> struct node_from_variant_t<521> { using type = SgListComprehension; };
21864
21865// Class: ListExp
21866template <> struct describe_node_t<SgListExp> {
21867 using node = SgListExp;
21868 using base = SgExprListExp;
21869 static constexpr char const * const name{"ListExp"};
21870 static constexpr unsigned long variant{522};
21871 static constexpr bool concrete{true};
21872 using subclasses_t = mp::List<>;
21873 using fields_t = mp::List<>;
21874};
21875template <> struct node_from_variant_t<522> { using type = SgListExp; };
21876
21877// Class: LocatedNode
21879 using parent = SgLocatedNode;
21880 using field_type = Sg_File_Info*;
21881 static constexpr size_t position{0};
21882 static constexpr char const * const name{"startOfConstruct"};
21883 static constexpr char const * const typestr{"Sg_File_Info*"};
21884 static constexpr bool traverse{false};
21885 static constexpr auto mbr_ptr{&SgLocatedNode::p_startOfConstruct};
21886 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21887 using bind = Desc<SgLocatedNode, Sg_File_Info* SgLocatedNode::*, &SgLocatedNode::p_startOfConstruct>;
21888};
21890 using parent = SgLocatedNode;
21891 using field_type = Sg_File_Info*;
21892 static constexpr size_t position{1};
21893 static constexpr char const * const name{"endOfConstruct"};
21894 static constexpr char const * const typestr{"Sg_File_Info*"};
21895 static constexpr bool traverse{false};
21896 static constexpr auto mbr_ptr{&SgLocatedNode::p_endOfConstruct};
21897 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21898 using bind = Desc<SgLocatedNode, Sg_File_Info* SgLocatedNode::*, &SgLocatedNode::p_endOfConstruct>;
21899};
21900template <> struct describe_field_t<SgLocatedNode,AttachedPreprocessingInfoType*,&SgLocatedNode::p_attachedPreprocessingInfoPtr> {
21901 using parent = SgLocatedNode;
21902 using field_type = AttachedPreprocessingInfoType*;
21903 static constexpr size_t position{2};
21904 static constexpr char const * const name{"attachedPreprocessingInfoPtr"};
21905 static constexpr char const * const typestr{"AttachedPreprocessingInfoType*"};
21906 static constexpr bool traverse{false};
21907 static constexpr auto mbr_ptr{&SgLocatedNode::p_attachedPreprocessingInfoPtr};
21908 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21909 using bind = Desc<SgLocatedNode, AttachedPreprocessingInfoType* SgLocatedNode::*, &SgLocatedNode::p_attachedPreprocessingInfoPtr>;
21910};
21911template <> struct describe_field_t<SgLocatedNode,AstAttributeMechanism*,&SgLocatedNode::p_attributeMechanism> {
21912 using parent = SgLocatedNode;
21914 static constexpr size_t position{3};
21915 static constexpr char const * const name{"attributeMechanism"};
21916 static constexpr char const * const typestr{"AstAttributeMechanism*"};
21917 static constexpr bool traverse{false};
21918 static constexpr auto mbr_ptr{&SgLocatedNode::p_attributeMechanism};
21919 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21920 using bind = Desc<SgLocatedNode, AstAttributeMechanism* SgLocatedNode::*, &SgLocatedNode::p_attributeMechanism>;
21921};
21922template <> struct describe_field_t<SgLocatedNode,bool,&SgLocatedNode::p_containsTransformationToSurroundingWhitespace> {
21923 using parent = SgLocatedNode;
21924 using field_type = bool;
21925 static constexpr size_t position{4};
21926 static constexpr char const * const name{"containsTransformationToSurroundingWhitespace"};
21927 static constexpr char const * const typestr{"bool"};
21928 static constexpr bool traverse{false};
21929 static constexpr auto mbr_ptr{&SgLocatedNode::p_containsTransformationToSurroundingWhitespace};
21930 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21931 using bind = Desc<SgLocatedNode, bool SgLocatedNode::*, &SgLocatedNode::p_containsTransformationToSurroundingWhitespace>;
21932};
21942template <> struct node_from_variant_t<523> { using type = SgLocatedNode; };
21943
21944// Class: LocatedNodeSupport
21946 using node = SgLocatedNodeSupport;
21947 using base = SgLocatedNode;
21948 static constexpr char const * const name{"LocatedNodeSupport"};
21949 static constexpr unsigned long variant{524};
21950 static constexpr bool concrete{false};
21952 using fields_t = mp::List<>;
21953};
21954template <> struct node_from_variant_t<524> { using type = SgLocatedNodeSupport; };
21955
21956// Class: LongDoubleVal
21958 using parent = SgLongDoubleVal;
21959 using field_type = long double;
21960 static constexpr size_t position{0};
21961 static constexpr char const * const name{"value"};
21962 static constexpr char const * const typestr{"long double"};
21963 static constexpr bool traverse{false};
21964 static constexpr auto mbr_ptr{&SgLongDoubleVal::p_value};
21965 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21966 using bind = Desc<SgLongDoubleVal, long double SgLongDoubleVal::*, &SgLongDoubleVal::p_value>;
21967};
21968template <> struct describe_field_t<SgLongDoubleVal,std::string,&SgLongDoubleVal::p_valueString> {
21969 using parent = SgLongDoubleVal;
21970 using field_type = std::string;
21971 static constexpr size_t position{1};
21972 static constexpr char const * const name{"valueString"};
21973 static constexpr char const * const typestr{"std::string"};
21974 static constexpr bool traverse{false};
21975 static constexpr auto mbr_ptr{&SgLongDoubleVal::p_valueString};
21976 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
21977 using bind = Desc<SgLongDoubleVal, std::string SgLongDoubleVal::*, &SgLongDoubleVal::p_valueString>;
21978};
21980 using node = SgLongDoubleVal;
21981 using base = SgValueExp;
21982 static constexpr char const * const name{"LongDoubleVal"};
21983 static constexpr unsigned long variant{525};
21984 static constexpr bool concrete{true};
21985 using subclasses_t = mp::List<>;
21987};
21988template <> struct node_from_variant_t<525> { using type = SgLongDoubleVal; };
21989
21990// Class: LongIntVal
21991template <> struct describe_field_t<SgLongIntVal,long int,&SgLongIntVal::p_value> {
21992 using parent = SgLongIntVal;
21993 using field_type = long int;
21994 static constexpr size_t position{0};
21995 static constexpr char const * const name{"value"};
21996 static constexpr char const * const typestr{"long int"};
21997 static constexpr bool traverse{false};
21998 static constexpr auto mbr_ptr{&SgLongIntVal::p_value};
21999 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22000 using bind = Desc<SgLongIntVal, long int SgLongIntVal::*, &SgLongIntVal::p_value>;
22001};
22002template <> struct describe_field_t<SgLongIntVal,std::string,&SgLongIntVal::p_valueString> {
22003 using parent = SgLongIntVal;
22004 using field_type = std::string;
22005 static constexpr size_t position{1};
22006 static constexpr char const * const name{"valueString"};
22007 static constexpr char const * const typestr{"std::string"};
22008 static constexpr bool traverse{false};
22009 static constexpr auto mbr_ptr{&SgLongIntVal::p_valueString};
22010 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22011 using bind = Desc<SgLongIntVal, std::string SgLongIntVal::*, &SgLongIntVal::p_valueString>;
22012};
22013template <> struct describe_node_t<SgLongIntVal> {
22014 using node = SgLongIntVal;
22015 using base = SgValueExp;
22016 static constexpr char const * const name{"LongIntVal"};
22017 static constexpr unsigned long variant{526};
22018 static constexpr bool concrete{true};
22019 using subclasses_t = mp::List<>;
22021};
22022template <> struct node_from_variant_t<526> { using type = SgLongIntVal; };
22023
22024// Class: LongLongIntVal
22025template <> struct describe_field_t<SgLongLongIntVal,long long int,&SgLongLongIntVal::p_value> {
22026 using parent = SgLongLongIntVal;
22027 using field_type = long long int;
22028 static constexpr size_t position{0};
22029 static constexpr char const * const name{"value"};
22030 static constexpr char const * const typestr{"long long int"};
22031 static constexpr bool traverse{false};
22032 static constexpr auto mbr_ptr{&SgLongLongIntVal::p_value};
22033 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22034 using bind = Desc<SgLongLongIntVal, long long int SgLongLongIntVal::*, &SgLongLongIntVal::p_value>;
22035};
22036template <> struct describe_field_t<SgLongLongIntVal,std::string,&SgLongLongIntVal::p_valueString> {
22037 using parent = SgLongLongIntVal;
22038 using field_type = std::string;
22039 static constexpr size_t position{1};
22040 static constexpr char const * const name{"valueString"};
22041 static constexpr char const * const typestr{"std::string"};
22042 static constexpr bool traverse{false};
22043 static constexpr auto mbr_ptr{&SgLongLongIntVal::p_valueString};
22044 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22045 using bind = Desc<SgLongLongIntVal, std::string SgLongLongIntVal::*, &SgLongLongIntVal::p_valueString>;
22046};
22048 using node = SgLongLongIntVal;
22049 using base = SgValueExp;
22050 static constexpr char const * const name{"LongLongIntVal"};
22051 static constexpr unsigned long variant{527};
22052 static constexpr bool concrete{true};
22053 using subclasses_t = mp::List<>;
22055};
22056template <> struct node_from_variant_t<527> { using type = SgLongLongIntVal; };
22057
22058// Class: LshiftAssignOp
22060 using node = SgLshiftAssignOp;
22061 using base = SgCompoundAssignOp;
22062 static constexpr char const * const name{"LshiftAssignOp"};
22063 static constexpr unsigned long variant{528};
22064 static constexpr bool concrete{true};
22065 using subclasses_t = mp::List<>;
22066 using fields_t = mp::List<>;
22067};
22068template <> struct node_from_variant_t<528> { using type = SgLshiftAssignOp; };
22069
22070// Class: LshiftOp
22071template <> struct describe_node_t<SgLshiftOp> {
22072 using node = SgLshiftOp;
22073 using base = SgBinaryOp;
22074 static constexpr char const * const name{"LshiftOp"};
22075 static constexpr unsigned long variant{529};
22076 static constexpr bool concrete{true};
22077 using subclasses_t = mp::List<>;
22078 using fields_t = mp::List<>;
22079};
22080template <> struct node_from_variant_t<529> { using type = SgLshiftOp; };
22081
22082// Class: MagicColonExp
22084 using node = SgMagicColonExp;
22085 using base = SgExpression;
22086 static constexpr char const * const name{"MagicColonExp"};
22087 static constexpr unsigned long variant{530};
22088 static constexpr bool concrete{true};
22089 using subclasses_t = mp::List<>;
22090 using fields_t = mp::List<>;
22091};
22092template <> struct node_from_variant_t<530> { using type = SgMagicColonExp; };
22093
22094// Class: MatrixExp
22095template <> struct describe_node_t<SgMatrixExp> {
22096 using node = SgMatrixExp;
22097 using base = SgExprListExp;
22098 static constexpr char const * const name{"MatrixExp"};
22099 static constexpr unsigned long variant{531};
22100 static constexpr bool concrete{true};
22101 using subclasses_t = mp::List<>;
22102 using fields_t = mp::List<>;
22103};
22104template <> struct node_from_variant_t<531> { using type = SgMatrixExp; };
22105
22106// Class: MatrixTransposeOp
22107template <> struct describe_field_t<SgMatrixTransposeOp,bool,&SgMatrixTransposeOp::p_is_conjugate> {
22109 using field_type = bool;
22110 static constexpr size_t position{0};
22111 static constexpr char const * const name{"is_conjugate"};
22112 static constexpr char const * const typestr{"bool"};
22113 static constexpr bool traverse{false};
22114 static constexpr auto mbr_ptr{&SgMatrixTransposeOp::p_is_conjugate};
22115 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22116 using bind = Desc<SgMatrixTransposeOp, bool SgMatrixTransposeOp::*, &SgMatrixTransposeOp::p_is_conjugate>;
22117};
22119 using node = SgMatrixTransposeOp;
22120 using base = SgUnaryOp;
22121 static constexpr char const * const name{"MatrixTransposeOp"};
22122 static constexpr unsigned long variant{532};
22123 static constexpr bool concrete{true};
22124 using subclasses_t = mp::List<>;
22126};
22127template <> struct node_from_variant_t<532> { using type = SgMatrixTransposeOp; };
22128
22129// Class: MatlabForStatement
22130template <> struct describe_field_t<SgMatlabForStatement,SgExpression*,&SgMatlabForStatement::p_index> {
22132 using field_type = SgExpression*;
22133 static constexpr size_t position{0};
22134 static constexpr char const * const name{"index"};
22135 static constexpr char const * const typestr{"SgExpression*"};
22136 static constexpr bool traverse{true};
22137 static constexpr auto mbr_ptr{&SgMatlabForStatement::p_index};
22138 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22139 using bind = Desc<SgMatlabForStatement, SgExpression* SgMatlabForStatement::*, &SgMatlabForStatement::p_index>;
22140};
22141template <> struct describe_field_t<SgMatlabForStatement,SgExpression*,&SgMatlabForStatement::p_range> {
22143 using field_type = SgExpression*;
22144 static constexpr size_t position{1};
22145 static constexpr char const * const name{"range"};
22146 static constexpr char const * const typestr{"SgExpression*"};
22147 static constexpr bool traverse{true};
22148 static constexpr auto mbr_ptr{&SgMatlabForStatement::p_range};
22149 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22150 using bind = Desc<SgMatlabForStatement, SgExpression* SgMatlabForStatement::*, &SgMatlabForStatement::p_range>;
22151};
22152template <> struct describe_field_t<SgMatlabForStatement,SgBasicBlock*,&SgMatlabForStatement::p_body> {
22154 using field_type = SgBasicBlock*;
22155 static constexpr size_t position{2};
22156 static constexpr char const * const name{"body"};
22157 static constexpr char const * const typestr{"SgBasicBlock*"};
22158 static constexpr bool traverse{true};
22159 static constexpr auto mbr_ptr{&SgMatlabForStatement::p_body};
22160 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22161 using bind = Desc<SgMatlabForStatement, SgBasicBlock* SgMatlabForStatement::*, &SgMatlabForStatement::p_body>;
22162};
22164 using node = SgMatlabForStatement;
22165 using base = SgScopeStatement;
22166 static constexpr char const * const name{"MatlabForStatement"};
22167 static constexpr unsigned long variant{533};
22168 static constexpr bool concrete{true};
22169 using subclasses_t = mp::List<>;
22171};
22172template <> struct node_from_variant_t<533> { using type = SgMatlabForStatement; };
22173
22174// Class: MemberFunctionDeclaration
22178 static constexpr size_t position{0};
22179 static constexpr char const * const name{"CtorInitializerList"};
22180 static constexpr char const * const typestr{"SgCtorInitializerList*"};
22181 static constexpr bool traverse{true};
22182 static constexpr auto mbr_ptr{&SgMemberFunctionDeclaration::p_CtorInitializerList};
22183 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22184 using bind = Desc<SgMemberFunctionDeclaration, SgCtorInitializerList* SgMemberFunctionDeclaration::*, &SgMemberFunctionDeclaration::p_CtorInitializerList>;
22185};
22186template <> struct describe_field_t<SgMemberFunctionDeclaration,SgDeclarationStatement*,&SgMemberFunctionDeclaration::p_associatedClassDeclaration> {
22189 static constexpr size_t position{1};
22190 static constexpr char const * const name{"associatedClassDeclaration"};
22191 static constexpr char const * const typestr{"SgDeclarationStatement*"};
22192 static constexpr bool traverse{false};
22193 static constexpr auto mbr_ptr{&SgMemberFunctionDeclaration::p_associatedClassDeclaration};
22194 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22195 using bind = Desc<SgMemberFunctionDeclaration, SgDeclarationStatement* SgMemberFunctionDeclaration::*, &SgMemberFunctionDeclaration::p_associatedClassDeclaration>;
22196};
22206template <> struct node_from_variant_t<534> { using type = SgMemberFunctionDeclaration; };
22207
22208// Class: MemberFunctionRefExp
22212 static constexpr size_t position{0};
22213 static constexpr char const * const name{"symbol_i"};
22214 static constexpr char const * const typestr{"SgMemberFunctionSymbol*"};
22215 static constexpr bool traverse{false};
22216 static constexpr auto mbr_ptr{&SgMemberFunctionRefExp::p_symbol_i};
22217 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22218 using bind = Desc<SgMemberFunctionRefExp, SgMemberFunctionSymbol* SgMemberFunctionRefExp::*, &SgMemberFunctionRefExp::p_symbol_i>;
22219};
22222 using field_type = int;
22223 static constexpr size_t position{1};
22224 static constexpr char const * const name{"virtual_call"};
22225 static constexpr char const * const typestr{"int"};
22226 static constexpr bool traverse{false};
22227 static constexpr auto mbr_ptr{&SgMemberFunctionRefExp::p_virtual_call};
22228 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22229 using bind = Desc<SgMemberFunctionRefExp, int SgMemberFunctionRefExp::*, &SgMemberFunctionRefExp::p_virtual_call>;
22230};
22233 using field_type = SgFunctionType*;
22234 static constexpr size_t position{2};
22235 static constexpr char const * const name{"function_type"};
22236 static constexpr char const * const typestr{"SgFunctionType*"};
22237 static constexpr bool traverse{false};
22238 static constexpr auto mbr_ptr{&SgMemberFunctionRefExp::p_function_type};
22239 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22240 using bind = Desc<SgMemberFunctionRefExp, SgFunctionType* SgMemberFunctionRefExp::*, &SgMemberFunctionRefExp::p_function_type>;
22241};
22244 using field_type = int;
22245 static constexpr size_t position{3};
22246 static constexpr char const * const name{"need_qualifier"};
22247 static constexpr char const * const typestr{"int"};
22248 static constexpr bool traverse{false};
22249 static constexpr auto mbr_ptr{&SgMemberFunctionRefExp::p_need_qualifier};
22250 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22251 using bind = Desc<SgMemberFunctionRefExp, int SgMemberFunctionRefExp::*, &SgMemberFunctionRefExp::p_need_qualifier>;
22252};
22253template <> struct describe_field_t<SgMemberFunctionRefExp,int,&SgMemberFunctionRefExp::p_name_qualification_length> {
22255 using field_type = int;
22256 static constexpr size_t position{4};
22257 static constexpr char const * const name{"name_qualification_length"};
22258 static constexpr char const * const typestr{"int"};
22259 static constexpr bool traverse{false};
22260 static constexpr auto mbr_ptr{&SgMemberFunctionRefExp::p_name_qualification_length};
22261 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22262 using bind = Desc<SgMemberFunctionRefExp, int SgMemberFunctionRefExp::*, &SgMemberFunctionRefExp::p_name_qualification_length>;
22263};
22264template <> struct describe_field_t<SgMemberFunctionRefExp,bool,&SgMemberFunctionRefExp::p_type_elaboration_required> {
22266 using field_type = bool;
22267 static constexpr size_t position{5};
22268 static constexpr char const * const name{"type_elaboration_required"};
22269 static constexpr char const * const typestr{"bool"};
22270 static constexpr bool traverse{false};
22271 static constexpr auto mbr_ptr{&SgMemberFunctionRefExp::p_type_elaboration_required};
22272 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22273 using bind = Desc<SgMemberFunctionRefExp, bool SgMemberFunctionRefExp::*, &SgMemberFunctionRefExp::p_type_elaboration_required>;
22274};
22275template <> struct describe_field_t<SgMemberFunctionRefExp,bool,&SgMemberFunctionRefExp::p_global_qualification_required> {
22277 using field_type = bool;
22278 static constexpr size_t position{6};
22279 static constexpr char const * const name{"global_qualification_required"};
22280 static constexpr char const * const typestr{"bool"};
22281 static constexpr bool traverse{false};
22282 static constexpr auto mbr_ptr{&SgMemberFunctionRefExp::p_global_qualification_required};
22283 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22284 using bind = Desc<SgMemberFunctionRefExp, bool SgMemberFunctionRefExp::*, &SgMemberFunctionRefExp::p_global_qualification_required>;
22285};
22295template <> struct node_from_variant_t<535> { using type = SgMemberFunctionRefExp; };
22296
22297// Class: MemberFunctionSymbol
22300 using base = SgFunctionSymbol;
22301 static constexpr char const * const name{"MemberFunctionSymbol"};
22302 static constexpr unsigned long variant{536};
22303 static constexpr bool concrete{true};
22305 using fields_t = mp::List<>;
22306};
22307template <> struct node_from_variant_t<536> { using type = SgMemberFunctionSymbol; };
22308
22309// Class: MemberFunctionType
22310template <> struct describe_field_t<SgMemberFunctionType,SgType*,&SgMemberFunctionType::p_class_type> {
22312 using field_type = SgType*;
22313 static constexpr size_t position{0};
22314 static constexpr char const * const name{"class_type"};
22315 static constexpr char const * const typestr{"SgType*"};
22316 static constexpr bool traverse{false};
22317 static constexpr auto mbr_ptr{&SgMemberFunctionType::p_class_type};
22318 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22319 using bind = Desc<SgMemberFunctionType, SgType* SgMemberFunctionType::*, &SgMemberFunctionType::p_class_type>;
22320};
22321template <> struct describe_field_t<SgMemberFunctionType,unsigned int,&SgMemberFunctionType::p_mfunc_specifier> {
22323 using field_type = unsigned int;
22324 static constexpr size_t position{1};
22325 static constexpr char const * const name{"mfunc_specifier"};
22326 static constexpr char const * const typestr{"unsigned int"};
22327 static constexpr bool traverse{false};
22328 static constexpr auto mbr_ptr{&SgMemberFunctionType::p_mfunc_specifier};
22329 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22330 using bind = Desc<SgMemberFunctionType, unsigned int SgMemberFunctionType::*, &SgMemberFunctionType::p_mfunc_specifier>;
22331};
22333 using node = SgMemberFunctionType;
22334 using base = SgFunctionType;
22335 static constexpr char const * const name{"MemberFunctionType"};
22336 static constexpr unsigned long variant{537};
22337 static constexpr bool concrete{true};
22340};
22341template <> struct node_from_variant_t<537> { using type = SgMemberFunctionType; };
22342
22343// Class: MembershipOp
22344template <> struct describe_node_t<SgMembershipOp> {
22345 using node = SgMembershipOp;
22346 using base = SgBinaryOp;
22347 static constexpr char const * const name{"MembershipOp"};
22348 static constexpr unsigned long variant{538};
22349 static constexpr bool concrete{true};
22350 using subclasses_t = mp::List<>;
22351 using fields_t = mp::List<>;
22352};
22353template <> struct node_from_variant_t<538> { using type = SgMembershipOp; };
22354
22355// Class: MicrosoftAttributeDeclaration
22356template <> struct describe_field_t<SgMicrosoftAttributeDeclaration,SgName,&SgMicrosoftAttributeDeclaration::p_attribute_string> {
22358 using field_type = SgName;
22359 static constexpr size_t position{0};
22360 static constexpr char const * const name{"attribute_string"};
22361 static constexpr char const * const typestr{"SgName"};
22362 static constexpr bool traverse{false};
22363 static constexpr auto mbr_ptr{&SgMicrosoftAttributeDeclaration::p_attribute_string};
22364 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22365 using bind = Desc<SgMicrosoftAttributeDeclaration, SgName SgMicrosoftAttributeDeclaration::*, &SgMicrosoftAttributeDeclaration::p_attribute_string>;
22366};
22370 static constexpr char const * const name{"MicrosoftAttributeDeclaration"};
22371 static constexpr unsigned long variant{539};
22372 static constexpr bool concrete{true};
22373 using subclasses_t = mp::List<>;
22375};
22376template <> struct node_from_variant_t<539> { using type = SgMicrosoftAttributeDeclaration; };
22377
22378// Class: MinusAssignOp
22380 using node = SgMinusAssignOp;
22381 using base = SgCompoundAssignOp;
22382 static constexpr char const * const name{"MinusAssignOp"};
22383 static constexpr unsigned long variant{540};
22384 static constexpr bool concrete{true};
22385 using subclasses_t = mp::List<>;
22386 using fields_t = mp::List<>;
22387};
22388template <> struct node_from_variant_t<540> { using type = SgMinusAssignOp; };
22389
22390// Class: MinusMinusOp
22391template <> struct describe_node_t<SgMinusMinusOp> {
22392 using node = SgMinusMinusOp;
22393 using base = SgUnaryOp;
22394 static constexpr char const * const name{"MinusMinusOp"};
22395 static constexpr unsigned long variant{541};
22396 static constexpr bool concrete{true};
22397 using subclasses_t = mp::List<>;
22398 using fields_t = mp::List<>;
22399};
22400template <> struct node_from_variant_t<541> { using type = SgMinusMinusOp; };
22401
22402// Class: MinusOp
22403template <> struct describe_node_t<SgMinusOp> {
22404 using node = SgMinusOp;
22405 using base = SgUnaryOp;
22406 static constexpr char const * const name{"MinusOp"};
22407 static constexpr unsigned long variant{542};
22408 static constexpr bool concrete{true};
22409 using subclasses_t = mp::List<>;
22410 using fields_t = mp::List<>;
22411};
22412template <> struct node_from_variant_t<542> { using type = SgMinusOp; };
22413
22414// Class: ModAssignOp
22415template <> struct describe_node_t<SgModAssignOp> {
22416 using node = SgModAssignOp;
22417 using base = SgCompoundAssignOp;
22418 static constexpr char const * const name{"ModAssignOp"};
22419 static constexpr unsigned long variant{543};
22420 static constexpr bool concrete{true};
22421 using subclasses_t = mp::List<>;
22422 using fields_t = mp::List<>;
22423};
22424template <> struct node_from_variant_t<543> { using type = SgModAssignOp; };
22425
22426// Class: ModOp
22427template <> struct describe_node_t<SgModOp> {
22428 using node = SgModOp;
22429 using base = SgBinaryOp;
22430 static constexpr char const * const name{"ModOp"};
22431 static constexpr unsigned long variant{544};
22432 static constexpr bool concrete{true};
22433 using subclasses_t = mp::List<>;
22434 using fields_t = mp::List<>;
22435};
22436template <> struct node_from_variant_t<544> { using type = SgModOp; };
22437
22438// Class: Modifier
22448template <> struct node_from_variant_t<545> { using type = SgModifier; };
22449
22450// Class: ModifierNodes
22451template <> struct describe_field_t<SgModifierNodes,SgModifierTypePtrVector,&SgModifierNodes::p_nodes> {
22452 using parent = SgModifierNodes;
22453 using field_type = SgModifierTypePtrVector;
22454 static constexpr size_t position{0};
22455 static constexpr char const * const name{"nodes"};
22456 static constexpr char const * const typestr{"SgModifierTypePtrVector"};
22457 static constexpr bool traverse{false};
22458 static constexpr auto mbr_ptr{&SgModifierNodes::p_nodes};
22459 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22460 using bind = Desc<SgModifierNodes, SgModifierTypePtrVector SgModifierNodes::*, &SgModifierNodes::p_nodes>;
22461};
22462template <> struct describe_field_t<SgModifierNodes,SgModifierNodes*,&SgModifierNodes::p_next> {
22463 using parent = SgModifierNodes;
22464 using field_type = SgModifierNodes*;
22465 static constexpr size_t position{1};
22466 static constexpr char const * const name{"next"};
22467 static constexpr char const * const typestr{"SgModifierNodes*"};
22468 static constexpr bool traverse{false};
22469 static constexpr auto mbr_ptr{&SgModifierNodes::p_next};
22470 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22471 using bind = Desc<SgModifierNodes, SgModifierNodes* SgModifierNodes::*, &SgModifierNodes::p_next>;
22472};
22474 using node = SgModifierNodes;
22475 using base = SgModifier;
22476 static constexpr char const * const name{"ModifierNodes"};
22477 static constexpr unsigned long variant{546};
22478 static constexpr bool concrete{true};
22479 using subclasses_t = mp::List<>;
22481};
22482template <> struct node_from_variant_t<546> { using type = SgModifierNodes; };
22483
22484// Class: ModifierType
22485template <> struct describe_field_t<SgModifierType,SgType*,&SgModifierType::p_base_type> {
22486 using parent = SgModifierType;
22487 using field_type = SgType*;
22488 static constexpr size_t position{0};
22489 static constexpr char const * const name{"base_type"};
22490 static constexpr char const * const typestr{"SgType*"};
22491 static constexpr bool traverse{true};
22492 static constexpr auto mbr_ptr{&SgModifierType::p_base_type};
22493 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22494 using bind = Desc<SgModifierType, SgType* SgModifierType::*, &SgModifierType::p_base_type>;
22495};
22496template <> struct describe_field_t<SgModifierType,SgTypeModifier,&SgModifierType::p_typeModifier> {
22497 using parent = SgModifierType;
22498 using field_type = SgTypeModifier;
22499 static constexpr size_t position{1};
22500 static constexpr char const * const name{"typeModifier"};
22501 static constexpr char const * const typestr{"SgTypeModifier"};
22502 static constexpr bool traverse{false};
22503 static constexpr auto mbr_ptr{&SgModifierType::p_typeModifier};
22504 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22505 using bind = Desc<SgModifierType, SgTypeModifier SgModifierType::*, &SgModifierType::p_typeModifier>;
22506};
22507template <> struct describe_field_t<SgModifierType,char*,&SgModifierType::p_frontend_type_reference> {
22508 using parent = SgModifierType;
22509 using field_type = char*;
22510 static constexpr size_t position{2};
22511 static constexpr char const * const name{"frontend_type_reference"};
22512 static constexpr char const * const typestr{"char*"};
22513 static constexpr bool traverse{false};
22514 static constexpr auto mbr_ptr{&SgModifierType::p_frontend_type_reference};
22515 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22516 using bind = Desc<SgModifierType, char* SgModifierType::*, &SgModifierType::p_frontend_type_reference>;
22517};
22518template <> struct describe_node_t<SgModifierType> {
22519 using node = SgModifierType;
22520 using base = SgType;
22521 static constexpr char const * const name{"ModifierType"};
22522 static constexpr unsigned long variant{547};
22523 static constexpr bool concrete{true};
22524 using subclasses_t = mp::List<>;
22526};
22527template <> struct node_from_variant_t<547> { using type = SgModifierType; };
22528
22529// Class: ModuleStatement
22530template <> struct describe_field_t<SgModuleStatement,SgLabelRefExp*,&SgModuleStatement::p_end_numeric_label> {
22531 using parent = SgModuleStatement;
22532 using field_type = SgLabelRefExp*;
22533 static constexpr size_t position{0};
22534 static constexpr char const * const name{"end_numeric_label"};
22535 static constexpr char const * const typestr{"SgLabelRefExp*"};
22536 static constexpr bool traverse{false};
22537 static constexpr auto mbr_ptr{&SgModuleStatement::p_end_numeric_label};
22538 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22539 using bind = Desc<SgModuleStatement, SgLabelRefExp* SgModuleStatement::*, &SgModuleStatement::p_end_numeric_label>;
22540};
22542 using node = SgModuleStatement;
22543 using base = SgClassDeclaration;
22544 static constexpr char const * const name{"ModuleStatement"};
22545 static constexpr unsigned long variant{548};
22546 static constexpr bool concrete{true};
22547 using subclasses_t = mp::List<>;
22549};
22550template <> struct node_from_variant_t<548> { using type = SgModuleStatement; };
22551
22552// Class: ModuleSymbol
22553template <> struct describe_field_t<SgModuleSymbol,SgModuleStatement*,&SgModuleSymbol::p_declaration> {
22554 using parent = SgModuleSymbol;
22556 static constexpr size_t position{0};
22557 static constexpr char const * const name{"declaration"};
22558 static constexpr char const * const typestr{"SgModuleStatement*"};
22559 static constexpr bool traverse{true};
22560 static constexpr auto mbr_ptr{&SgModuleSymbol::p_declaration};
22561 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22562 using bind = Desc<SgModuleSymbol, SgModuleStatement* SgModuleSymbol::*, &SgModuleSymbol::p_declaration>;
22563};
22564template <> struct describe_node_t<SgModuleSymbol> {
22565 using node = SgModuleSymbol;
22566 using base = SgSymbol;
22567 static constexpr char const * const name{"ModuleSymbol"};
22568 static constexpr unsigned long variant{549};
22569 static constexpr bool concrete{true};
22570 using subclasses_t = mp::List<>;
22572};
22573template <> struct node_from_variant_t<549> { using type = SgModuleSymbol; };
22574
22575// Class: MultAssignOp
22576template <> struct describe_node_t<SgMultAssignOp> {
22577 using node = SgMultAssignOp;
22578 using base = SgCompoundAssignOp;
22579 static constexpr char const * const name{"MultAssignOp"};
22580 static constexpr unsigned long variant{550};
22581 static constexpr bool concrete{true};
22582 using subclasses_t = mp::List<>;
22583 using fields_t = mp::List<>;
22584};
22585template <> struct node_from_variant_t<550> { using type = SgMultAssignOp; };
22586
22587// Class: MultiplyOp
22588template <> struct describe_node_t<SgMultiplyOp> {
22589 using node = SgMultiplyOp;
22590 using base = SgBinaryOp;
22591 static constexpr char const * const name{"MultiplyOp"};
22592 static constexpr unsigned long variant{551};
22593 static constexpr bool concrete{true};
22594 using subclasses_t = mp::List<>;
22595 using fields_t = mp::List<>;
22596};
22597template <> struct node_from_variant_t<551> { using type = SgMultiplyOp; };
22598
22599// Class: Name
22600template <> struct describe_field_t<SgName,std::string,&SgName::p_char> {
22601 using parent = SgName;
22602 using field_type = std::string;
22603 static constexpr size_t position{0};
22604 static constexpr char const * const name{"char"};
22605 static constexpr char const * const typestr{"std::string"};
22606 static constexpr bool traverse{false};
22607 static constexpr auto mbr_ptr{&SgName::p_char};
22608 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22609 using bind = Desc<SgName, std::string SgName::*, &SgName::p_char>;
22610};
22611template <> struct describe_node_t<SgName> {
22612 using node = SgName;
22613 using base = SgSupport;
22614 static constexpr char const * const name{"Name"};
22615 static constexpr unsigned long variant{552};
22616 static constexpr bool concrete{true};
22617 using subclasses_t = mp::List<>;
22619};
22620template <> struct node_from_variant_t<552> { using type = SgName; };
22621
22622// Class: NameGroup
22623template <> struct describe_field_t<SgNameGroup,std::string,&SgNameGroup::p_group_name> {
22624 using parent = SgNameGroup;
22625 using field_type = std::string;
22626 static constexpr size_t position{0};
22627 static constexpr char const * const name{"group_name"};
22628 static constexpr char const * const typestr{"std::string"};
22629 static constexpr bool traverse{false};
22630 static constexpr auto mbr_ptr{&SgNameGroup::p_group_name};
22631 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22632 using bind = Desc<SgNameGroup, std::string SgNameGroup::*, &SgNameGroup::p_group_name>;
22633};
22634template <> struct describe_field_t<SgNameGroup,SgStringList,&SgNameGroup::p_name_list> {
22635 using parent = SgNameGroup;
22636 using field_type = SgStringList;
22637 static constexpr size_t position{1};
22638 static constexpr char const * const name{"name_list"};
22639 static constexpr char const * const typestr{"SgStringList"};
22640 static constexpr bool traverse{false};
22641 static constexpr auto mbr_ptr{&SgNameGroup::p_name_list};
22642 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22643 using bind = Desc<SgNameGroup, SgStringList SgNameGroup::*, &SgNameGroup::p_name_list>;
22644};
22645template <> struct describe_node_t<SgNameGroup> {
22646 using node = SgNameGroup;
22647 using base = SgSupport;
22648 static constexpr char const * const name{"NameGroup"};
22649 static constexpr unsigned long variant{553};
22650 static constexpr bool concrete{true};
22651 using subclasses_t = mp::List<>;
22653};
22654template <> struct node_from_variant_t<553> { using type = SgNameGroup; };
22655
22656// Class: NamedType
22657template <> struct describe_field_t<SgNamedType,SgDeclarationStatement*,&SgNamedType::p_declaration> {
22658 using parent = SgNamedType;
22660 static constexpr size_t position{0};
22661 static constexpr char const * const name{"declaration"};
22662 static constexpr char const * const typestr{"SgDeclarationStatement*"};
22663 static constexpr bool traverse{true};
22664 static constexpr auto mbr_ptr{&SgNamedType::p_declaration};
22665 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22666 using bind = Desc<SgNamedType, SgDeclarationStatement* SgNamedType::*, &SgNamedType::p_declaration>;
22667};
22668template <> struct describe_field_t<SgNamedType,bool,&SgNamedType::p_autonomous_declaration> {
22669 using parent = SgNamedType;
22670 using field_type = bool;
22671 static constexpr size_t position{1};
22672 static constexpr char const * const name{"autonomous_declaration"};
22673 static constexpr char const * const typestr{"bool"};
22674 static constexpr bool traverse{false};
22675 static constexpr auto mbr_ptr{&SgNamedType::p_autonomous_declaration};
22676 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22677 using bind = Desc<SgNamedType, bool SgNamedType::*, &SgNamedType::p_autonomous_declaration>;
22678};
22679template <> struct describe_field_t<SgNamedType,bool,&SgNamedType::p_is_from_template_parameter> {
22680 using parent = SgNamedType;
22681 using field_type = bool;
22682 static constexpr size_t position{2};
22683 static constexpr char const * const name{"is_from_template_parameter"};
22684 static constexpr char const * const typestr{"bool"};
22685 static constexpr bool traverse{false};
22686 static constexpr auto mbr_ptr{&SgNamedType::p_is_from_template_parameter};
22687 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22688 using bind = Desc<SgNamedType, bool SgNamedType::*, &SgNamedType::p_is_from_template_parameter>;
22689};
22699template <> struct node_from_variant_t<554> { using type = SgNamedType; };
22700
22701// Class: NamelistStatement
22702template <> struct describe_field_t<SgNamelistStatement,SgNameGroupPtrList,&SgNamelistStatement::p_group_list> {
22704 using field_type = SgNameGroupPtrList;
22705 static constexpr size_t position{0};
22706 static constexpr char const * const name{"group_list"};
22707 static constexpr char const * const typestr{"SgNameGroupPtrList"};
22708 static constexpr bool traverse{false};
22709 static constexpr auto mbr_ptr{&SgNamelistStatement::p_group_list};
22710 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22711 using bind = Desc<SgNamelistStatement, SgNameGroupPtrList SgNamelistStatement::*, &SgNamelistStatement::p_group_list>;
22712};
22714 using node = SgNamelistStatement;
22716 static constexpr char const * const name{"NamelistStatement"};
22717 static constexpr unsigned long variant{555};
22718 static constexpr bool concrete{true};
22719 using subclasses_t = mp::List<>;
22721};
22722template <> struct node_from_variant_t<555> { using type = SgNamelistStatement; };
22723
22724// Class: NamespaceAliasDeclarationStatement
22727 using field_type = SgName;
22728 static constexpr size_t position{0};
22729 static constexpr char const * const name{"name"};
22730 static constexpr char const * const typestr{"SgName"};
22731 static constexpr bool traverse{false};
22732 static constexpr auto mbr_ptr{&SgNamespaceAliasDeclarationStatement::p_name};
22733 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22734 using bind = Desc<SgNamespaceAliasDeclarationStatement, SgName SgNamespaceAliasDeclarationStatement::*, &SgNamespaceAliasDeclarationStatement::p_name>;
22735};
22739 static constexpr size_t position{1};
22740 static constexpr char const * const name{"namespaceDeclaration"};
22741 static constexpr char const * const typestr{"SgNamespaceDeclarationStatement*"};
22742 static constexpr bool traverse{false};
22744 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22745 using bind = Desc<SgNamespaceAliasDeclarationStatement, SgNamespaceDeclarationStatement* SgNamespaceAliasDeclarationStatement::*, &SgNamespaceAliasDeclarationStatement::p_namespaceDeclaration>;
22746};
22747template <> struct describe_field_t<SgNamespaceAliasDeclarationStatement,int,&SgNamespaceAliasDeclarationStatement::p_name_qualification_length> {
22749 using field_type = int;
22750 static constexpr size_t position{2};
22751 static constexpr char const * const name{"name_qualification_length"};
22752 static constexpr char const * const typestr{"int"};
22753 static constexpr bool traverse{false};
22754 static constexpr auto mbr_ptr{&SgNamespaceAliasDeclarationStatement::p_name_qualification_length};
22755 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22756 using bind = Desc<SgNamespaceAliasDeclarationStatement, int SgNamespaceAliasDeclarationStatement::*, &SgNamespaceAliasDeclarationStatement::p_name_qualification_length>;
22757};
22758template <> struct describe_field_t<SgNamespaceAliasDeclarationStatement,bool,&SgNamespaceAliasDeclarationStatement::p_type_elaboration_required> {
22760 using field_type = bool;
22761 static constexpr size_t position{3};
22762 static constexpr char const * const name{"type_elaboration_required"};
22763 static constexpr char const * const typestr{"bool"};
22764 static constexpr bool traverse{false};
22765 static constexpr auto mbr_ptr{&SgNamespaceAliasDeclarationStatement::p_type_elaboration_required};
22766 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22767 using bind = Desc<SgNamespaceAliasDeclarationStatement, bool SgNamespaceAliasDeclarationStatement::*, &SgNamespaceAliasDeclarationStatement::p_type_elaboration_required>;
22768};
22769template <> struct describe_field_t<SgNamespaceAliasDeclarationStatement,bool,&SgNamespaceAliasDeclarationStatement::p_global_qualification_required> {
22771 using field_type = bool;
22772 static constexpr size_t position{4};
22773 static constexpr char const * const name{"global_qualification_required"};
22774 static constexpr char const * const typestr{"bool"};
22775 static constexpr bool traverse{false};
22776 static constexpr auto mbr_ptr{&SgNamespaceAliasDeclarationStatement::p_global_qualification_required};
22777 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22778 using bind = Desc<SgNamespaceAliasDeclarationStatement, bool SgNamespaceAliasDeclarationStatement::*, &SgNamespaceAliasDeclarationStatement::p_global_qualification_required>;
22779};
22780template <> struct describe_field_t<SgNamespaceAliasDeclarationStatement,bool,&SgNamespaceAliasDeclarationStatement::p_is_alias_for_another_namespace_alias> {
22782 using field_type = bool;
22783 static constexpr size_t position{5};
22784 static constexpr char const * const name{"is_alias_for_another_namespace_alias"};
22785 static constexpr char const * const typestr{"bool"};
22786 static constexpr bool traverse{false};
22787 static constexpr auto mbr_ptr{&SgNamespaceAliasDeclarationStatement::p_is_alias_for_another_namespace_alias};
22788 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22789 using bind = Desc<SgNamespaceAliasDeclarationStatement, bool SgNamespaceAliasDeclarationStatement::*, &SgNamespaceAliasDeclarationStatement::p_is_alias_for_another_namespace_alias>;
22790};
22791template <> struct describe_field_t<SgNamespaceAliasDeclarationStatement,SgNamespaceAliasDeclarationStatement*,&SgNamespaceAliasDeclarationStatement::p_namespaceAliasDeclaration> {
22794 static constexpr size_t position{6};
22795 static constexpr char const * const name{"namespaceAliasDeclaration"};
22796 static constexpr char const * const typestr{"SgNamespaceAliasDeclarationStatement*"};
22797 static constexpr bool traverse{false};
22798 static constexpr auto mbr_ptr{&SgNamespaceAliasDeclarationStatement::p_namespaceAliasDeclaration};
22799 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22800 using bind = Desc<SgNamespaceAliasDeclarationStatement, SgNamespaceAliasDeclarationStatement* SgNamespaceAliasDeclarationStatement::*, &SgNamespaceAliasDeclarationStatement::p_namespaceAliasDeclaration>;
22801};
22811template <> struct node_from_variant_t<556> { using type = SgNamespaceAliasDeclarationStatement; };
22812
22813// Class: NamespaceDeclarationStatement
22816 using field_type = SgName;
22817 static constexpr size_t position{0};
22818 static constexpr char const * const name{"name"};
22819 static constexpr char const * const typestr{"SgName"};
22820 static constexpr bool traverse{false};
22821 static constexpr auto mbr_ptr{&SgNamespaceDeclarationStatement::p_name};
22822 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22823 using bind = Desc<SgNamespaceDeclarationStatement, SgName SgNamespaceDeclarationStatement::*, &SgNamespaceDeclarationStatement::p_name>;
22824};
22828 static constexpr size_t position{1};
22829 static constexpr char const * const name{"definition"};
22830 static constexpr char const * const typestr{"SgNamespaceDefinitionStatement*"};
22831 static constexpr bool traverse{true};
22832 static constexpr auto mbr_ptr{&SgNamespaceDeclarationStatement::p_definition};
22833 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22834 using bind = Desc<SgNamespaceDeclarationStatement, SgNamespaceDefinitionStatement* SgNamespaceDeclarationStatement::*, &SgNamespaceDeclarationStatement::p_definition>;
22835};
22838 using field_type = bool;
22839 static constexpr size_t position{2};
22840 static constexpr char const * const name{"isUnnamedNamespace"};
22841 static constexpr char const * const typestr{"bool"};
22842 static constexpr bool traverse{false};
22843 static constexpr auto mbr_ptr{&SgNamespaceDeclarationStatement::p_isUnnamedNamespace};
22844 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22845 using bind = Desc<SgNamespaceDeclarationStatement, bool SgNamespaceDeclarationStatement::*, &SgNamespaceDeclarationStatement::p_isUnnamedNamespace>;
22846};
22847template <> struct describe_field_t<SgNamespaceDeclarationStatement,bool,&SgNamespaceDeclarationStatement::p_isInlinedNamespace> {
22849 using field_type = bool;
22850 static constexpr size_t position{3};
22851 static constexpr char const * const name{"isInlinedNamespace"};
22852 static constexpr char const * const typestr{"bool"};
22853 static constexpr bool traverse{false};
22854 static constexpr auto mbr_ptr{&SgNamespaceDeclarationStatement::p_isInlinedNamespace};
22855 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22856 using bind = Desc<SgNamespaceDeclarationStatement, bool SgNamespaceDeclarationStatement::*, &SgNamespaceDeclarationStatement::p_isInlinedNamespace>;
22857};
22867template <> struct node_from_variant_t<557> { using type = SgNamespaceDeclarationStatement; };
22868
22869// Class: NamespaceDefinitionStatement
22872 using field_type = SgDeclarationStatementPtrList;
22873 static constexpr size_t position{0};
22874 static constexpr char const * const name{"declarations"};
22875 static constexpr char const * const typestr{"SgDeclarationStatementPtrList"};
22876 static constexpr bool traverse{true};
22877 static constexpr auto mbr_ptr{&SgNamespaceDefinitionStatement::p_declarations};
22878 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22879 using bind = Desc<SgNamespaceDefinitionStatement, SgDeclarationStatementPtrList SgNamespaceDefinitionStatement::*, &SgNamespaceDefinitionStatement::p_declarations>;
22880};
22884 static constexpr size_t position{1};
22885 static constexpr char const * const name{"namespaceDeclaration"};
22886 static constexpr char const * const typestr{"SgNamespaceDeclarationStatement*"};
22887 static constexpr bool traverse{false};
22888 static constexpr auto mbr_ptr{&SgNamespaceDefinitionStatement::p_namespaceDeclaration};
22889 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22890 using bind = Desc<SgNamespaceDefinitionStatement, SgNamespaceDeclarationStatement* SgNamespaceDefinitionStatement::*, &SgNamespaceDefinitionStatement::p_namespaceDeclaration>;
22891};
22892template <> struct describe_field_t<SgNamespaceDefinitionStatement,SgNamespaceDefinitionStatement*,&SgNamespaceDefinitionStatement::p_previousNamespaceDefinition> {
22895 static constexpr size_t position{2};
22896 static constexpr char const * const name{"previousNamespaceDefinition"};
22897 static constexpr char const * const typestr{"SgNamespaceDefinitionStatement*"};
22898 static constexpr bool traverse{false};
22899 static constexpr auto mbr_ptr{&SgNamespaceDefinitionStatement::p_previousNamespaceDefinition};
22900 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22901 using bind = Desc<SgNamespaceDefinitionStatement, SgNamespaceDefinitionStatement* SgNamespaceDefinitionStatement::*, &SgNamespaceDefinitionStatement::p_previousNamespaceDefinition>;
22902};
22903template <> struct describe_field_t<SgNamespaceDefinitionStatement,SgNamespaceDefinitionStatement*,&SgNamespaceDefinitionStatement::p_nextNamespaceDefinition> {
22906 static constexpr size_t position{3};
22907 static constexpr char const * const name{"nextNamespaceDefinition"};
22908 static constexpr char const * const typestr{"SgNamespaceDefinitionStatement*"};
22909 static constexpr bool traverse{false};
22910 static constexpr auto mbr_ptr{&SgNamespaceDefinitionStatement::p_nextNamespaceDefinition};
22911 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22912 using bind = Desc<SgNamespaceDefinitionStatement, SgNamespaceDefinitionStatement* SgNamespaceDefinitionStatement::*, &SgNamespaceDefinitionStatement::p_nextNamespaceDefinition>;
22913};
22914template <> struct describe_field_t<SgNamespaceDefinitionStatement,SgNamespaceDefinitionStatement*,&SgNamespaceDefinitionStatement::p_global_definition> {
22917 static constexpr size_t position{4};
22918 static constexpr char const * const name{"global_definition"};
22919 static constexpr char const * const typestr{"SgNamespaceDefinitionStatement*"};
22920 static constexpr bool traverse{false};
22921 static constexpr auto mbr_ptr{&SgNamespaceDefinitionStatement::p_global_definition};
22922 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22923 using bind = Desc<SgNamespaceDefinitionStatement, SgNamespaceDefinitionStatement* SgNamespaceDefinitionStatement::*, &SgNamespaceDefinitionStatement::p_global_definition>;
22924};
22925template <> struct describe_field_t<SgNamespaceDefinitionStatement,bool,&SgNamespaceDefinitionStatement::p_isUnionOfReentrantNamespaceDefinitions> {
22927 using field_type = bool;
22928 static constexpr size_t position{5};
22929 static constexpr char const * const name{"isUnionOfReentrantNamespaceDefinitions"};
22930 static constexpr char const * const typestr{"bool"};
22931 static constexpr bool traverse{false};
22932 static constexpr auto mbr_ptr{&SgNamespaceDefinitionStatement::p_isUnionOfReentrantNamespaceDefinitions};
22933 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22934 using bind = Desc<SgNamespaceDefinitionStatement, bool SgNamespaceDefinitionStatement::*, &SgNamespaceDefinitionStatement::p_isUnionOfReentrantNamespaceDefinitions>;
22935};
22945template <> struct node_from_variant_t<558> { using type = SgNamespaceDefinitionStatement; };
22946
22947// Class: NamespaceSymbol
22948template <> struct describe_field_t<SgNamespaceSymbol,SgName,&SgNamespaceSymbol::p_name> {
22949 using parent = SgNamespaceSymbol;
22950 using field_type = SgName;
22951 static constexpr size_t position{0};
22952 static constexpr char const * const name{"name"};
22953 static constexpr char const * const typestr{"SgName"};
22954 static constexpr bool traverse{false};
22955 static constexpr auto mbr_ptr{&SgNamespaceSymbol::p_name};
22956 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22957 using bind = Desc<SgNamespaceSymbol, SgName SgNamespaceSymbol::*, &SgNamespaceSymbol::p_name>;
22958};
22959template <> struct describe_field_t<SgNamespaceSymbol,SgNamespaceDeclarationStatement*,&SgNamespaceSymbol::p_declaration> {
22960 using parent = SgNamespaceSymbol;
22962 static constexpr size_t position{1};
22963 static constexpr char const * const name{"declaration"};
22964 static constexpr char const * const typestr{"SgNamespaceDeclarationStatement*"};
22965 static constexpr bool traverse{true};
22966 static constexpr auto mbr_ptr{&SgNamespaceSymbol::p_declaration};
22967 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22968 using bind = Desc<SgNamespaceSymbol, SgNamespaceDeclarationStatement* SgNamespaceSymbol::*, &SgNamespaceSymbol::p_declaration>;
22969};
22970template <> struct describe_field_t<SgNamespaceSymbol,SgNamespaceAliasDeclarationStatement*,&SgNamespaceSymbol::p_aliasDeclaration> {
22971 using parent = SgNamespaceSymbol;
22973 static constexpr size_t position{2};
22974 static constexpr char const * const name{"aliasDeclaration"};
22975 static constexpr char const * const typestr{"SgNamespaceAliasDeclarationStatement*"};
22976 static constexpr bool traverse{true};
22977 static constexpr auto mbr_ptr{&SgNamespaceSymbol::p_aliasDeclaration};
22978 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22979 using bind = Desc<SgNamespaceSymbol, SgNamespaceAliasDeclarationStatement* SgNamespaceSymbol::*, &SgNamespaceSymbol::p_aliasDeclaration>;
22980};
22981template <> struct describe_field_t<SgNamespaceSymbol,bool,&SgNamespaceSymbol::p_isAlias> {
22982 using parent = SgNamespaceSymbol;
22983 using field_type = bool;
22984 static constexpr size_t position{3};
22985 static constexpr char const * const name{"isAlias"};
22986 static constexpr char const * const typestr{"bool"};
22987 static constexpr bool traverse{false};
22988 static constexpr auto mbr_ptr{&SgNamespaceSymbol::p_isAlias};
22989 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
22990 using bind = Desc<SgNamespaceSymbol, bool SgNamespaceSymbol::*, &SgNamespaceSymbol::p_isAlias>;
22991};
23001template <> struct node_from_variant_t<559> { using type = SgNamespaceSymbol; };
23002
23003// Class: NaryOp
23004template <> struct describe_field_t<SgNaryOp,SgExpressionPtrList,&SgNaryOp::p_operands> {
23005 using parent = SgNaryOp;
23006 using field_type = SgExpressionPtrList;
23007 static constexpr size_t position{0};
23008 static constexpr char const * const name{"operands"};
23009 static constexpr char const * const typestr{"SgExpressionPtrList"};
23010 static constexpr bool traverse{true};
23011 static constexpr auto mbr_ptr{&SgNaryOp::p_operands};
23012 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
23013 using bind = Desc<SgNaryOp, SgExpressionPtrList SgNaryOp::*, &SgNaryOp::p_operands>;
23014};
23015template <> struct describe_field_t<SgNaryOp,VariantTList,&SgNaryOp::p_operators> {
23016 using parent = SgNaryOp;
23017 using field_type = VariantTList;
23018 static constexpr size_t position{1};
23019 static constexpr char const * const name{"operators"};
23020 static constexpr char const * const typestr{"VariantTList"};
23021 static constexpr bool traverse{false};
23022 static constexpr auto mbr_ptr{&SgNaryOp::p_operators};
23023 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
23024 using bind = Desc<SgNaryOp, VariantTList SgNaryOp::*, &SgNaryOp::p_operators>;
23025};
23026template <> struct describe_node_t<SgNaryOp> {
23027 using node = SgNaryOp;
23028 using base = SgExpression;
23029 static constexpr char const * const name{"NaryOp"};
23030 static constexpr unsigned long variant{560};
23031 static constexpr bool concrete{false};
23034};
23035template <> struct node_from_variant_t<560> { using type = SgNaryOp; };
23036
23037// Class: NaryBooleanOp
23039 using node = SgNaryBooleanOp;
23040 using base = SgNaryOp;
23041 static constexpr char const * const name{"NaryBooleanOp"};
23042 static constexpr unsigned long variant{561};
23043 static constexpr bool concrete{true};
23044 using subclasses_t = mp::List<>;
23045 using fields_t = mp::List<>;
23046};
23047template <> struct node_from_variant_t<561> { using type = SgNaryBooleanOp; };
23048
23049// Class: NaryComparisonOp
23051 using node = SgNaryComparisonOp;
23052 using base = SgNaryOp;
23053 static constexpr char const * const name{"NaryComparisonOp"};
23054 static constexpr unsigned long variant{562};
23055 static constexpr bool concrete{true};
23056 using subclasses_t = mp::List<>;
23057 using fields_t = mp::List<>;
23058};
23059template <> struct node_from_variant_t<562> { using type = SgNaryComparisonOp; };
23060
23061// Class: NewExp
23062template <> struct describe_field_t<SgNewExp,SgType*,&SgNewExp::p_specified_type> {
23063 using parent = SgNewExp;
23064 using field_type = SgType*;
23065 static constexpr size_t position{0};
23066 static constexpr char const * const name{"specified_type"};
23067 static constexpr char const * const typestr{"SgType*"};
23068 static constexpr bool traverse{false};
23069 static constexpr auto mbr_ptr{&SgNewExp::p_specified_type};
23070 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
23071 using bind = Desc<SgNewExp, SgType* SgNewExp::*, &SgNewExp::p_specified_type>;
23072};
23074 using parent = SgNewExp;
23075 using field_type = SgExprListExp*;
23076 static constexpr size_t position{1};
23077 static constexpr char const * const name{"placement_args"};
23078 static constexpr char const * const typestr{"SgExprListExp*"};
23079 static constexpr bool traverse{true};
23080 static constexpr auto mbr_ptr{&SgNewExp::p_placement_args};
23081 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
23082 using bind = Desc<SgNewExp, SgExprListExp* SgNewExp::*, &SgNewExp::p_placement_args>;
23083};
23085 using parent = SgNewExp;
23087 static constexpr size_t position{2};
23088 static constexpr char const * const name{"constructor_args"};
23089 static constexpr char const * const typestr{"SgConstructorInitializer*"};
23090 static constexpr bool traverse{true};
23091 static constexpr auto mbr_ptr{&SgNewExp::p_constructor_args};
23092 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
23093 using bind = Desc<SgNewExp, SgConstructorInitializer* SgNewExp::*, &SgNewExp::p_constructor_args>;
23094};
23096 using parent = SgNewExp;
23097 using field_type = SgExpression*;
23098 static constexpr size_t position{3};
23099 static constexpr char const * const name{"builtin_args"};
23100 static constexpr char const * const typestr{"SgExpression*"};
23101 static constexpr bool traverse{true};
23102 static constexpr auto mbr_ptr{&SgNewExp::p_builtin_args};
23103 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
23104 using bind = Desc<SgNewExp, SgExpression* SgNewExp::*, &SgNewExp::p_builtin_args>;
23105};
23107 using parent = SgNewExp;
23108 using field_type = short;
23109 static constexpr size_t position{4};
23110 static constexpr char const * const name{"need_global_specifier"};
23111 static constexpr char const * const typestr{"short"};
23112 static constexpr bool traverse{false};
23113 static constexpr auto mbr_ptr{&SgNewExp::p_need_global_specifier};
23114 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
23115 using bind = Desc<SgNewExp, short SgNewExp::*, &SgNewExp::p_need_global_specifier>;
23116};
23117template <> struct describe_field_t<SgNewExp,SgFunctionDeclaration*,&SgNewExp::p_newOperatorDeclaration> {
23118 using parent = SgNewExp;
23120 static constexpr size_t position{5};
23121 static constexpr char const * const name{"newOperatorDeclaration"};
23122 static constexpr char const * const typestr{"SgFunctionDeclaration*"};
23123 static constexpr bool traverse{false};
23124 static constexpr auto mbr_ptr{&SgNewExp::p_newOperatorDeclaration};
23125 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
23126 using bind = Desc<SgNewExp, SgFunctionDeclaration* SgNewExp::*, &SgNewExp::p_newOperatorDeclaration>;
23127};
23128template <> struct describe_field_t<SgNewExp,int,&SgNewExp::p_name_qualification_length> {
23129 using parent = SgNewExp;
23130 using field_type = int;
23131 static constexpr size_t position{6};
23132 static constexpr char const * const name{"name_qualification_length"};
23133 static constexpr char const * const typestr{"int"};
23134 static constexpr bool traverse{false};
23135 static constexpr auto mbr_ptr{&SgNewExp::p_name_qualification_length};
23136 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
23137 using bind = Desc<SgNewExp, int SgNewExp::*, &SgNewExp::p_name_qualification_length>;
23138};
23139template <> struct describe_field_t<SgNewExp,bool,&SgNewExp::p_type_elaboration_required> {
23140 using parent = SgNewExp;
23141 using field_type = bool;
23142 static constexpr size_t position{7};
23143 static constexpr char const * const name{"type_elaboration_required"};
23144 static constexpr char const * const typestr{"bool"};
23145 static constexpr bool traverse{false};
23146 static constexpr auto mbr_ptr{&SgNewExp::p_type_elaboration_required};
23147 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
23148 using bind = Desc<SgNewExp, bool SgNewExp::*, &SgNewExp::p_type_elaboration_required>;
23149};
23150template <> struct describe_field_t<SgNewExp,bool,&SgNewExp::p_global_qualification_required> {
23151 using parent = SgNewExp;
23152 using field_type = bool;
23153 static constexpr size_t position{8};
23154 static constexpr char const * const name{"global_qualification_required"};
23155 static constexpr char const * const typestr{"bool"};
23156 static constexpr bool traverse{false};
23157 static constexpr auto mbr_ptr{&SgNewExp::p_global_qualification_required};
23158 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
23159 using bind = Desc<SgNewExp, bool SgNewExp::*, &SgNewExp::p_global_qualification_required>;
23160};
23161template <> struct describe_field_t<SgNewExp,int,&SgNewExp::p_name_qualification_for_pointer_to_member_class_length> {
23162 using parent = SgNewExp;
23163 using field_type = int;
23164 static constexpr size_t position{9};
23165 static constexpr char const * const name{"name_qualification_for_pointer_to_member_class_length"};
23166 static constexpr char const * const typestr{"int"};
23167 static constexpr bool traverse{false};
23168 static constexpr auto mbr_ptr{&SgNewExp::p_name_qualification_for_pointer_to_member_class_length};
23169 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
23170 using bind = Desc<SgNewExp, int SgNewExp::*, &SgNewExp::p_name_qualification_for_pointer_to_member_class_length>;
23171};
23172template <> struct describe_field_t<SgNewExp,bool,&SgNewExp::p_type_elaboration_for_pointer_to_member_class_required> {
23173 using parent = SgNewExp;
23174 using field_type = bool;
23175 static constexpr size_t position{10};
23176 static constexpr char const * const name{"type_elaboration_for_pointer_to_member_class_required"};
23177 static constexpr char const * const typestr{"bool"};
23178 static constexpr bool traverse{false};
23179 static constexpr auto mbr_ptr{&SgNewExp::p_type_elaboration_for_pointer_to_member_class_required};
23180 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
23181 using bind = Desc<SgNewExp, bool SgNewExp::*, &SgNewExp::p_type_elaboration_for_pointer_to_member_class_required>;
23182};
23183template <> struct describe_field_t<SgNewExp,bool,&SgNewExp::p_global_qualification_for_pointer_to_member_class_required> {
23184 using parent = SgNewExp;
23185 using field_type = bool;
23186 static constexpr size_t position{11};
23187 static constexpr char const * const name{"global_qualification_for_pointer_to_member_class_required"};
23188 static constexpr char const * const typestr{"bool"};
23189 static constexpr bool traverse{false};
23190 static constexpr auto mbr_ptr{&SgNewExp::p_global_qualification_for_pointer_to_member_class_required};
23191 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
23192 using bind = Desc<SgNewExp, bool SgNewExp::*, &SgNewExp::p_global_qualification_for_pointer_to_member_class_required>;
23193};
23203template <> struct node_from_variant_t<563> { using type = SgNewExp; };
23204
23205// Class: Node
23207 using parent = SgNode;
23208 using field_type = SgNode*;
23209 static constexpr size_t position{0};
23210 static constexpr char const * const name{"parent"};
23211 static constexpr char const * const typestr{"SgNode*"};
23212 static constexpr bool traverse{false};
23213 static constexpr auto mbr_ptr{&SgNode::p_parent};
23214 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
23215 using bind = Desc<SgNode, SgNode* SgNode::*, &SgNode::p_parent>;
23216};
23218 using parent = SgNode;
23219 using field_type = bool;
23220 static constexpr size_t position{1};
23221 static constexpr char const * const name{"isModified"};
23222 static constexpr char const * const typestr{"bool"};
23223 static constexpr bool traverse{false};
23224 static constexpr auto mbr_ptr{&SgNode::p_isModified};
23225 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
23226 using bind = Desc<SgNode, bool SgNode::*, &SgNode::p_isModified>;
23227};
23228template <> struct describe_field_t<SgNode,bool,&SgNode::p_containsTransformation> {
23229 using parent = SgNode;
23230 using field_type = bool;
23231 static constexpr size_t position{2};
23232 static constexpr char const * const name{"containsTransformation"};
23233 static constexpr char const * const typestr{"bool"};
23234 static constexpr bool traverse{false};
23235 static constexpr auto mbr_ptr{&SgNode::p_containsTransformation};
23236 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
23237 using bind = Desc<SgNode, bool SgNode::*, &SgNode::p_containsTransformation>;
23238};
23240 using parent = SgNode;
23241 using field_type = SgNode*;
23242 static constexpr size_t position{3};
23243 static constexpr char const * const name{"freepointer"};
23244 static constexpr char const * const typestr{"SgNode*"};
23245 static constexpr bool traverse{false};
23246 static constexpr auto mbr_ptr{&SgNode::p_freepointer};
23247 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
23248 using bind = Desc<SgNode, SgNode* SgNode::*, &SgNode::p_freepointer>;
23249};
23250template <> struct describe_node_t<SgNode> {
23251 using node = SgNode;
23252 using base = void;
23253 static constexpr char const * const name{"Node"};
23254 static constexpr unsigned long variant{564};
23255 static constexpr bool concrete{false};
23258};
23259template <> struct node_from_variant_t<564> { using type = SgNode; };
23260
23261// Class: NoexceptOp
23262template <> struct describe_field_t<SgNoexceptOp,SgExpression*,&SgNoexceptOp::p_operand_expr> {
23263 using parent = SgNoexceptOp;
23264 using field_type = SgExpression*;
23265 static constexpr size_t position{0};
23266 static constexpr char const * const name{"operand_expr"};
23267 static constexpr char const * const typestr{"SgExpression*"};
23268 static constexpr bool traverse{true};
23269 static constexpr auto mbr_ptr{&SgNoexceptOp::p_operand_expr};
23270 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
23271 using bind = Desc<SgNoexceptOp, SgExpression* SgNoexceptOp::*, &SgNoexceptOp::p_operand_expr>;
23272};
23273template <> struct describe_node_t<SgNoexceptOp> {
23274 using node = SgNoexceptOp;
23275 using base = SgExpression;
23276 static constexpr char const * const name{"NoexceptOp"};
23277 static constexpr unsigned long variant{565};
23278 static constexpr bool concrete{true};
23279 using subclasses_t = mp::List<>;
23281};
23282template <> struct node_from_variant_t<565> { using type = SgNoexceptOp; };
23283
23284// Class: NotEqualOp
23285template <> struct describe_node_t<SgNotEqualOp> {
23286 using node = SgNotEqualOp;
23287 using base = SgBinaryOp;
23288 static constexpr char const * const name{"NotEqualOp"};
23289 static constexpr unsigned long variant{566};
23290 static constexpr bool concrete{true};
23291 using subclasses_t = mp::List<>;
23292 using fields_t = mp::List<>;
23293};
23294template <> struct node_from_variant_t<566> { using type = SgNotEqualOp; };
23295
23296// Class: NotOp
23297template <> struct describe_node_t<SgNotOp> {
23298 using node = SgNotOp;
23299 using base = SgUnaryOp;
23300 static constexpr char const * const name{"NotOp"};
23301 static constexpr unsigned long variant{567};
23302 static constexpr bool concrete{true};
23303 using subclasses_t = mp::List<>;
23304 using fields_t = mp::List<>;
23305};
23306template <> struct node_from_variant_t<567> { using type = SgNotOp; };
23307
23308// Class: NonMembershipOp
23310 using node = SgNonMembershipOp;
23311 using base = SgBinaryOp;
23312 static constexpr char const * const name{"NonMembershipOp"};
23313 static constexpr unsigned long variant{568};
23314 static constexpr bool concrete{true};
23315 using subclasses_t = mp::List<>;
23316 using fields_t = mp::List<>;
23317};
23318template <> struct node_from_variant_t<568> { using type = SgNonMembershipOp; };
23319
23320// Class: NonrealDecl
23321template <> struct describe_field_t<SgNonrealDecl,SgName,&SgNonrealDecl::p_name> {
23322 using parent = SgNonrealDecl;
23323 using field_type = SgName;
23324 static constexpr size_t position{0};
23325 static constexpr char const * const name{"name"};
23326 static constexpr char const * const typestr{"SgName"};
23327 static constexpr bool traverse{false};
23328 static constexpr auto mbr_ptr{&SgNonrealDecl::p_name};
23329 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
23330 using bind = Desc<SgNonrealDecl, SgName SgNonrealDecl::*, &SgNonrealDecl::p_name>;
23331};
23332template <> struct describe_field_t<SgNonrealDecl,SgDeclarationScope*,&SgNonrealDecl::p_nonreal_decl_scope> {
23333 using parent = SgNonrealDecl;
23335 static constexpr size_t position{1};
23336 static constexpr char const * const name{"nonreal_decl_scope"};
23337 static constexpr char const * const typestr{"SgDeclarationScope*"};
23338 static constexpr bool traverse{false};
23339 static constexpr auto mbr_ptr{&SgNonrealDecl::p_nonreal_decl_scope};
23340 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
23341 using bind = Desc<SgNonrealDecl, SgDeclarationScope* SgNonrealDecl::*, &SgNonrealDecl::p_nonreal_decl_scope>;
23342};
23343template <> struct describe_field_t<SgNonrealDecl,SgNonrealType*,&SgNonrealDecl::p_type> {
23344 using parent = SgNonrealDecl;
23345 using field_type = SgNonrealType*;
23346 static constexpr size_t position{2};
23347 static constexpr char const * const name{"type"};
23348 static constexpr char const * const typestr{"SgNonrealType*"};
23349 static constexpr bool traverse{false};
23350 static constexpr auto mbr_ptr{&SgNonrealDecl::p_type};
23351 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
23352 using bind = Desc<SgNonrealDecl, SgNonrealType* SgNonrealDecl::*, &SgNonrealDecl::p_type>;
23353};
23354template <> struct describe_field_t<SgNonrealDecl,int,&SgNonrealDecl::p_template_parameter_position> {
23355 using parent = SgNonrealDecl;
23356 using field_type = int;
23357 static constexpr size_t position{3};
23358 static constexpr char const * const name{"template_parameter_position"};
23359 static constexpr char const * const typestr{"int"};
23360 static constexpr bool traverse{false};
23361 static constexpr auto mbr_ptr{&SgNonrealDecl::p_template_parameter_position};
23362 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
23363 using bind = Desc<SgNonrealDecl, int SgNonrealDecl::*, &SgNonrealDecl::p_template_parameter_position>;
23364};
23365template <> struct describe_field_t<SgNonrealDecl,int,&SgNonrealDecl::p_template_parameter_depth> {
23366 using parent = SgNonrealDecl;
23367 using field_type = int;
23368 static constexpr size_t position{4};
23369 static constexpr char const * const name{"template_parameter_depth"};
23370 static constexpr char const * const typestr{"int"};
23371 static constexpr bool traverse{false};
23372 static constexpr auto mbr_ptr{&SgNonrealDecl::p_template_parameter_depth};
23373 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
23374 using bind = Desc<SgNonrealDecl, int SgNonrealDecl::*, &SgNonrealDecl::p_template_parameter_depth>;
23375};
23376template <> struct describe_field_t<SgNonrealDecl,SgDeclarationStatement*,&SgNonrealDecl::p_templateDeclaration> {
23377 using parent = SgNonrealDecl;
23379 static constexpr size_t position{5};
23380 static constexpr char const * const name{"templateDeclaration"};
23381 static constexpr char const * const typestr{"SgDeclarationStatement*"};
23382 static constexpr bool traverse{false};
23383 static constexpr auto mbr_ptr{&SgNonrealDecl::p_templateDeclaration};
23384 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
23385 using bind = Desc<SgNonrealDecl, SgDeclarationStatement* SgNonrealDecl::*, &SgNonrealDecl::p_templateDeclaration>;
23386};
23387template <> struct describe_field_t<SgNonrealDecl,SgTemplateArgumentPtrList,&SgNonrealDecl::p_tpl_args> {
23388 using parent = SgNonrealDecl;
23389 using field_type = SgTemplateArgumentPtrList;
23390 static constexpr size_t position{6};
23391 static constexpr char const * const name{"tpl_args"};
23392 static constexpr char const * const typestr{"SgTemplateArgumentPtrList"};
23393 static constexpr bool traverse{false};
23394 static constexpr auto mbr_ptr{&SgNonrealDecl::p_tpl_args};
23395 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
23396 using bind = Desc<SgNonrealDecl, SgTemplateArgumentPtrList SgNonrealDecl::*, &SgNonrealDecl::p_tpl_args>;
23397};
23398template <> struct describe_field_t<SgNonrealDecl,SgTemplateParameterPtrList,&SgNonrealDecl::p_tpl_params> {
23399 using parent = SgNonrealDecl;
23400 using field_type = SgTemplateParameterPtrList;
23401 static constexpr size_t position{7};
23402 static constexpr char const * const name{"tpl_params"};
23403 static constexpr char const * const typestr{"SgTemplateParameterPtrList"};
23404 static constexpr bool traverse{false};
23405 static constexpr auto mbr_ptr{&SgNonrealDecl::p_tpl_params};
23406 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
23407 using bind = Desc<SgNonrealDecl, SgTemplateParameterPtrList SgNonrealDecl::*, &SgNonrealDecl::p_tpl_params>;
23408};
23409template <> struct describe_field_t<SgNonrealDecl,bool,&SgNonrealDecl::p_is_class_member> {
23410 using parent = SgNonrealDecl;
23411 using field_type = bool;
23412 static constexpr size_t position{8};
23413 static constexpr char const * const name{"is_class_member"};
23414 static constexpr char const * const typestr{"bool"};
23415 static constexpr bool traverse{false};
23416 static constexpr auto mbr_ptr{&SgNonrealDecl::p_is_class_member};
23417 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
23418 using bind = Desc<SgNonrealDecl, bool SgNonrealDecl::*, &SgNonrealDecl::p_is_class_member>;
23419};
23420template <> struct describe_field_t<SgNonrealDecl,bool,&SgNonrealDecl::p_is_template_param> {
23421 using parent = SgNonrealDecl;
23422 using field_type = bool;
23423 static constexpr size_t position{9};
23424 static constexpr char const * const name{"is_template_param"};
23425 static constexpr char const * const typestr{"bool"};
23426 static constexpr bool traverse{false};
23427 static constexpr auto mbr_ptr{&SgNonrealDecl::p_is_template_param};
23428 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
23429 using bind = Desc<SgNonrealDecl, bool SgNonrealDecl::*, &SgNonrealDecl::p_is_template_param>;
23430};
23431template <> struct describe_field_t<SgNonrealDecl,bool,&SgNonrealDecl::p_is_template_template_param> {
23432 using parent = SgNonrealDecl;
23433 using field_type = bool;
23434 static constexpr size_t position{10};
23435 static constexpr char const * const name{"is_template_template_param"};
23436 static constexpr char const * const typestr{"bool"};
23437 static constexpr bool traverse{false};
23438 static constexpr auto mbr_ptr{&SgNonrealDecl::p_is_template_template_param};
23439 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
23440 using bind = Desc<SgNonrealDecl, bool SgNonrealDecl::*, &SgNonrealDecl::p_is_template_template_param>;
23441};
23442template <> struct describe_field_t<SgNonrealDecl,bool,&SgNonrealDecl::p_is_nonreal_template> {
23443 using parent = SgNonrealDecl;
23444 using field_type = bool;
23445 static constexpr size_t position{11};
23446 static constexpr char const * const name{"is_nonreal_template"};
23447 static constexpr char const * const typestr{"bool"};
23448 static constexpr bool traverse{false};
23449 static constexpr auto mbr_ptr{&SgNonrealDecl::p_is_nonreal_template};
23450 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
23451 using bind = Desc<SgNonrealDecl, bool SgNonrealDecl::*, &SgNonrealDecl::p_is_nonreal_template>;
23452};
23453template <> struct describe_field_t<SgNonrealDecl,bool,&SgNonrealDecl::p_is_nonreal_function> {
23454 using parent = SgNonrealDecl;
23455 using field_type = bool;
23456 static constexpr size_t position{12};
23457 static constexpr char const * const name{"is_nonreal_function"};
23458 static constexpr char const * const typestr{"bool"};
23459 static constexpr bool traverse{false};
23460 static constexpr auto mbr_ptr{&SgNonrealDecl::p_is_nonreal_function};
23461 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
23462 using bind = Desc<SgNonrealDecl, bool SgNonrealDecl::*, &SgNonrealDecl::p_is_nonreal_function>;
23463};
23473template <> struct node_from_variant_t<569> { using type = SgNonrealDecl; };
23474
23475// Class: NonrealRefExp
23476template <> struct describe_field_t<SgNonrealRefExp,SgNonrealSymbol*,&SgNonrealRefExp::p_symbol> {
23477 using parent = SgNonrealRefExp;
23478 using field_type = SgNonrealSymbol*;
23479 static constexpr size_t position{0};
23480 static constexpr char const * const name{"symbol"};
23481 static constexpr char const * const typestr{"SgNonrealSymbol*"};
23482 static constexpr bool traverse{false};
23483 static constexpr auto mbr_ptr{&SgNonrealRefExp::p_symbol};
23484 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
23485 using bind = Desc<SgNonrealRefExp, SgNonrealSymbol* SgNonrealRefExp::*, &SgNonrealRefExp::p_symbol>;
23486};
23487template <> struct describe_field_t<SgNonrealRefExp,int,&SgNonrealRefExp::p_name_qualification_length> {
23488 using parent = SgNonrealRefExp;
23489 using field_type = int;
23490 static constexpr size_t position{1};
23491 static constexpr char const * const name{"name_qualification_length"};
23492 static constexpr char const * const typestr{"int"};
23493 static constexpr bool traverse{false};
23494 static constexpr auto mbr_ptr{&SgNonrealRefExp::p_name_qualification_length};
23495 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
23496 using bind = Desc<SgNonrealRefExp, int SgNonrealRefExp::*, &SgNonrealRefExp::p_name_qualification_length>;
23497};
23498template <> struct describe_field_t<SgNonrealRefExp,bool,&SgNonrealRefExp::p_type_elaboration_required> {
23499 using parent = SgNonrealRefExp;
23500 using field_type = bool;
23501 static constexpr size_t position{2};
23502 static constexpr char const * const name{"type_elaboration_required"};
23503 static constexpr char const * const typestr{"bool"};
23504 static constexpr bool traverse{false};
23505 static constexpr auto mbr_ptr{&SgNonrealRefExp::p_type_elaboration_required};
23506 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
23507 using bind = Desc<SgNonrealRefExp, bool SgNonrealRefExp::*, &SgNonrealRefExp::p_type_elaboration_required>;
23508};
23509template <> struct describe_field_t<SgNonrealRefExp,bool,&SgNonrealRefExp::p_global_qualification_required> {
23510 using parent = SgNonrealRefExp;
23511 using field_type = bool;
23512 static constexpr size_t position{3};
23513 static constexpr char const * const name{"global_qualification_required"};
23514 static constexpr char const * const typestr{"bool"};
23515 static constexpr bool traverse{false};
23516 static constexpr auto mbr_ptr{&SgNonrealRefExp::p_global_qualification_required};
23517 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
23518 using bind = Desc<SgNonrealRefExp, bool SgNonrealRefExp::*, &SgNonrealRefExp::p_global_qualification_required>;
23519};
23529template <> struct node_from_variant_t<570> { using type = SgNonrealRefExp; };
23530
23531// Class: NonrealSymbol
23532template <> struct describe_field_t<SgNonrealSymbol,SgNonrealDecl*,&SgNonrealSymbol::p_declaration> {
23533 using parent = SgNonrealSymbol;
23534 using field_type = SgNonrealDecl*;
23535 static constexpr size_t position{0};
23536 static constexpr char const * const name{"declaration"};
23537 static constexpr char const * const typestr{"SgNonrealDecl*"};
23538 static constexpr bool traverse{true};
23539 static constexpr auto mbr_ptr{&SgNonrealSymbol::p_declaration};
23540 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
23541 using bind = Desc<SgNonrealSymbol, SgNonrealDecl* SgNonrealSymbol::*, &SgNonrealSymbol::p_declaration>;
23542};
23544 using node = SgNonrealSymbol;
23545 using base = SgSymbol;
23546 static constexpr char const * const name{"NonrealSymbol"};
23547 static constexpr unsigned long variant{571};
23548 static constexpr bool concrete{true};
23549 using subclasses_t = mp::List<>;
23551};
23552template <> struct node_from_variant_t<571> { using type = SgNonrealSymbol; };
23553
23554// Class: NonrealType
23555template <> struct describe_node_t<SgNonrealType> {
23556 using node = SgNonrealType;
23557 using base = SgNamedType;
23558 static constexpr char const * const name{"NonrealType"};
23559 static constexpr unsigned long variant{572};
23560 static constexpr bool concrete{true};
23561 using subclasses_t = mp::List<>;
23562 using fields_t = mp::List<>;
23563};
23564template <> struct node_from_variant_t<572> { using type = SgNonrealType; };
23565
23566// Class: NonrealBaseClass
23567template <> struct describe_field_t<SgNonrealBaseClass,SgNonrealDecl*,&SgNonrealBaseClass::p_base_class_nonreal> {
23568 using parent = SgNonrealBaseClass;
23569 using field_type = SgNonrealDecl*;
23570 static constexpr size_t position{0};
23571 static constexpr char const * const name{"base_class_nonreal"};
23572 static constexpr char const * const typestr{"SgNonrealDecl*"};
23573 static constexpr bool traverse{true};
23574 static constexpr auto mbr_ptr{&SgNonrealBaseClass::p_base_class_nonreal};
23575 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
23576 using bind = Desc<SgNonrealBaseClass, SgNonrealDecl* SgNonrealBaseClass::*, &SgNonrealBaseClass::p_base_class_nonreal>;
23577};
23579 using node = SgNonrealBaseClass;
23580 using base = SgBaseClass;
23581 static constexpr char const * const name{"NonrealBaseClass"};
23582 static constexpr unsigned long variant{573};
23583 static constexpr bool concrete{true};
23584 using subclasses_t = mp::List<>;
23586};
23587template <> struct node_from_variant_t<573> { using type = SgNonrealBaseClass; };
23588
23589// Class: NullExpression
23591 using node = SgNullExpression;
23592 using base = SgExpression;
23593 static constexpr char const * const name{"NullExpression"};
23594 static constexpr unsigned long variant{574};
23595 static constexpr bool concrete{true};
23596 using subclasses_t = mp::List<>;
23597 using fields_t = mp::List<>;
23598};
23599template <> struct node_from_variant_t<574> { using type = SgNullExpression; };
23600
23601// Class: NullptrValExp
23603 using node = SgNullptrValExp;
23604 using base = SgValueExp;
23605 static constexpr char const * const name{"NullptrValExp"};
23606 static constexpr unsigned long variant{575};
23607 static constexpr bool concrete{true};
23608 using subclasses_t = mp::List<>;
23609 using fields_t = mp::List<>;
23610};
23611template <> struct node_from_variant_t<575> { using type = SgNullptrValExp; };
23612
23613// Class: NullStatement
23615 using node = SgNullStatement;
23616 using base = SgStatement;
23617 static constexpr char const * const name{"NullStatement"};
23618 static constexpr unsigned long variant{576};
23619 static constexpr bool concrete{true};
23620 using subclasses_t = mp::List<>;
23621 using fields_t = mp::List<>;
23622};
23623template <> struct node_from_variant_t<576> { using type = SgNullStatement; };
23624
23625// Class: NullifyStatement
23626template <> struct describe_field_t<SgNullifyStatement,SgExprListExp*,&SgNullifyStatement::p_pointer_list> {
23627 using parent = SgNullifyStatement;
23628 using field_type = SgExprListExp*;
23629 static constexpr size_t position{0};
23630 static constexpr char const * const name{"pointer_list"};
23631 static constexpr char const * const typestr{"SgExprListExp*"};
23632 static constexpr bool traverse{true};
23633 static constexpr auto mbr_ptr{&SgNullifyStatement::p_pointer_list};
23634 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
23635 using bind = Desc<SgNullifyStatement, SgExprListExp* SgNullifyStatement::*, &SgNullifyStatement::p_pointer_list>;
23636};
23638 using node = SgNullifyStatement;
23639 using base = SgStatement;
23640 static constexpr char const * const name{"NullifyStatement"};
23641 static constexpr unsigned long variant{577};
23642 static constexpr bool concrete{true};
23643 using subclasses_t = mp::List<>;
23645};
23646template <> struct node_from_variant_t<577> { using type = SgNullifyStatement; };
23647
23648// Class: OmpAtomicStatement
23650 using node = SgOmpAtomicStatement;
23652 static constexpr char const * const name{"OmpAtomicStatement"};
23653 static constexpr unsigned long variant{578};
23654 static constexpr bool concrete{true};
23655 using subclasses_t = mp::List<>;
23656 using fields_t = mp::List<>;
23657};
23658template <> struct node_from_variant_t<578> { using type = SgOmpAtomicStatement; };
23659
23660// Class: OmpBarrierStatement
23663 using base = SgStatement;
23664 static constexpr char const * const name{"OmpBarrierStatement"};
23665 static constexpr unsigned long variant{579};
23666 static constexpr bool concrete{true};
23667 using subclasses_t = mp::List<>;
23668 using fields_t = mp::List<>;
23669};
23670template <> struct node_from_variant_t<579> { using type = SgOmpBarrierStatement; };
23671
23672// Class: OmpCriticalStatement
23673template <> struct describe_field_t<SgOmpCriticalStatement,SgName,&SgOmpCriticalStatement::p_name> {
23675 using field_type = SgName;
23676 static constexpr size_t position{0};
23677 static constexpr char const * const name{"name"};
23678 static constexpr char const * const typestr{"SgName"};
23679 static constexpr bool traverse{false};
23680 static constexpr auto mbr_ptr{&SgOmpCriticalStatement::p_name};
23681 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
23682 using bind = Desc<SgOmpCriticalStatement, SgName SgOmpCriticalStatement::*, &SgOmpCriticalStatement::p_name>;
23683};
23686 using base = SgOmpBodyStatement;
23687 static constexpr char const * const name{"OmpCriticalStatement"};
23688 static constexpr unsigned long variant{580};
23689 static constexpr bool concrete{true};
23690 using subclasses_t = mp::List<>;
23692};
23693template <> struct node_from_variant_t<580> { using type = SgOmpCriticalStatement; };
23694
23695// Class: OmpClauseBodyStatement
23696template <> struct describe_field_t<SgOmpClauseBodyStatement,SgOmpClausePtrList,&SgOmpClauseBodyStatement::p_clauses> {
23698 using field_type = SgOmpClausePtrList;
23699 static constexpr size_t position{0};
23700 static constexpr char const * const name{"clauses"};
23701 static constexpr char const * const typestr{"SgOmpClausePtrList"};
23702 static constexpr bool traverse{true};
23703 static constexpr auto mbr_ptr{&SgOmpClauseBodyStatement::p_clauses};
23704 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
23705 using bind = Desc<SgOmpClauseBodyStatement, SgOmpClausePtrList SgOmpClauseBodyStatement::*, &SgOmpClauseBodyStatement::p_clauses>;
23706};
23716template <> struct node_from_variant_t<581> { using type = SgOmpClauseBodyStatement; };
23717
23718// Class: OmpBodyStatement
23719template <> struct describe_field_t<SgOmpBodyStatement,SgStatement*,&SgOmpBodyStatement::p_body> {
23720 using parent = SgOmpBodyStatement;
23721 using field_type = SgStatement*;
23722 static constexpr size_t position{0};
23723 static constexpr char const * const name{"body"};
23724 static constexpr char const * const typestr{"SgStatement*"};
23725 static constexpr bool traverse{true};
23726 static constexpr auto mbr_ptr{&SgOmpBodyStatement::p_body};
23727 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
23728 using bind = Desc<SgOmpBodyStatement, SgStatement* SgOmpBodyStatement::*, &SgOmpBodyStatement::p_body>;
23729};
23731 using node = SgOmpBodyStatement;
23732 using base = SgStatement;
23733 static constexpr char const * const name{"OmpBodyStatement"};
23734 static constexpr unsigned long variant{582};
23735 static constexpr bool concrete{false};
23738};
23739template <> struct node_from_variant_t<582> { using type = SgOmpBodyStatement; };
23740
23741// Class: OmpDoStatement
23743 using node = SgOmpDoStatement;
23745 static constexpr char const * const name{"OmpDoStatement"};
23746 static constexpr unsigned long variant{583};
23747 static constexpr bool concrete{true};
23748 using subclasses_t = mp::List<>;
23749 using fields_t = mp::List<>;
23750};
23751template <> struct node_from_variant_t<583> { using type = SgOmpDoStatement; };
23752
23753// Class: OmpFlushStatement
23754template <> struct describe_field_t<SgOmpFlushStatement,SgVarRefExpPtrList,&SgOmpFlushStatement::p_variables> {
23756 using field_type = SgVarRefExpPtrList;
23757 static constexpr size_t position{0};
23758 static constexpr char const * const name{"variables"};
23759 static constexpr char const * const typestr{"SgVarRefExpPtrList"};
23760 static constexpr bool traverse{true};
23761 static constexpr auto mbr_ptr{&SgOmpFlushStatement::p_variables};
23762 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
23763 using bind = Desc<SgOmpFlushStatement, SgVarRefExpPtrList SgOmpFlushStatement::*, &SgOmpFlushStatement::p_variables>;
23764};
23766 using node = SgOmpFlushStatement;
23767 using base = SgStatement;
23768 static constexpr char const * const name{"OmpFlushStatement"};
23769 static constexpr unsigned long variant{584};
23770 static constexpr bool concrete{true};
23771 using subclasses_t = mp::List<>;
23773};
23774template <> struct node_from_variant_t<584> { using type = SgOmpFlushStatement; };
23775
23776// Class: OmpDeclareSimdStatement
23777template <> struct describe_field_t<SgOmpDeclareSimdStatement,SgOmpClausePtrList,&SgOmpDeclareSimdStatement::p_clauses> {
23779 using field_type = SgOmpClausePtrList;
23780 static constexpr size_t position{0};
23781 static constexpr char const * const name{"clauses"};
23782 static constexpr char const * const typestr{"SgOmpClausePtrList"};
23783 static constexpr bool traverse{true};
23784 static constexpr auto mbr_ptr{&SgOmpDeclareSimdStatement::p_clauses};
23785 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
23786 using bind = Desc<SgOmpDeclareSimdStatement, SgOmpClausePtrList SgOmpDeclareSimdStatement::*, &SgOmpDeclareSimdStatement::p_clauses>;
23787};
23791 static constexpr char const * const name{"OmpDeclareSimdStatement"};
23792 static constexpr unsigned long variant{585};
23793 static constexpr bool concrete{true};
23794 using subclasses_t = mp::List<>;
23796};
23797template <> struct node_from_variant_t<585> { using type = SgOmpDeclareSimdStatement; };
23798
23799// Class: OmpForStatement
23801 using node = SgOmpForStatement;
23803 static constexpr char const * const name{"OmpForStatement"};
23804 static constexpr unsigned long variant{586};
23805 static constexpr bool concrete{true};
23806 using subclasses_t = mp::List<>;
23807 using fields_t = mp::List<>;
23808};
23809template <> struct node_from_variant_t<586> { using type = SgOmpForStatement; };
23810
23811// Class: OmpForSimdStatement
23815 static constexpr char const * const name{"OmpForSimdStatement"};
23816 static constexpr unsigned long variant{587};
23817 static constexpr bool concrete{true};
23818 using subclasses_t = mp::List<>;
23819 using fields_t = mp::List<>;
23820};
23821template <> struct node_from_variant_t<587> { using type = SgOmpForSimdStatement; };
23822
23823// Class: OmpMasterStatement
23825 using node = SgOmpMasterStatement;
23826 using base = SgOmpBodyStatement;
23827 static constexpr char const * const name{"OmpMasterStatement"};
23828 static constexpr unsigned long variant{588};
23829 static constexpr bool concrete{true};
23830 using subclasses_t = mp::List<>;
23831 using fields_t = mp::List<>;
23832};
23833template <> struct node_from_variant_t<588> { using type = SgOmpMasterStatement; };
23834
23835// Class: OmpOrderedStatement
23838 using base = SgOmpBodyStatement;
23839 static constexpr char const * const name{"OmpOrderedStatement"};
23840 static constexpr unsigned long variant{589};
23841 static constexpr bool concrete{true};
23842 using subclasses_t = mp::List<>;
23843 using fields_t = mp::List<>;
23844};
23845template <> struct node_from_variant_t<589> { using type = SgOmpOrderedStatement; };
23846
23847// Class: OmpParallelStatement
23851 static constexpr char const * const name{"OmpParallelStatement"};
23852 static constexpr unsigned long variant{590};
23853 static constexpr bool concrete{true};
23854 using subclasses_t = mp::List<>;
23855 using fields_t = mp::List<>;
23856};
23857template <> struct node_from_variant_t<590> { using type = SgOmpParallelStatement; };
23858
23859// Class: OmpSectionStatement
23862 using base = SgOmpBodyStatement;
23863 static constexpr char const * const name{"OmpSectionStatement"};
23864 static constexpr unsigned long variant{591};
23865 static constexpr bool concrete{true};
23866 using subclasses_t = mp::List<>;
23867 using fields_t = mp::List<>;
23868};
23869template <> struct node_from_variant_t<591> { using type = SgOmpSectionStatement; };
23870
23871// Class: OmpSectionsStatement
23875 static constexpr char const * const name{"OmpSectionsStatement"};
23876 static constexpr unsigned long variant{592};
23877 static constexpr bool concrete{true};
23878 using subclasses_t = mp::List<>;
23879 using fields_t = mp::List<>;
23880};
23881template <> struct node_from_variant_t<592> { using type = SgOmpSectionsStatement; };
23882
23883// Class: OmpSingleStatement
23885 using node = SgOmpSingleStatement;
23887 static constexpr char const * const name{"OmpSingleStatement"};
23888 static constexpr unsigned long variant{593};
23889 static constexpr bool concrete{true};
23890 using subclasses_t = mp::List<>;
23891 using fields_t = mp::List<>;
23892};
23893template <> struct node_from_variant_t<593> { using type = SgOmpSingleStatement; };
23894
23895// Class: OmpTaskStatement
23897 using node = SgOmpTaskStatement;
23899 static constexpr char const * const name{"OmpTaskStatement"};
23900 static constexpr unsigned long variant{594};
23901 static constexpr bool concrete{true};
23902 using subclasses_t = mp::List<>;
23903 using fields_t = mp::List<>;
23904};
23905template <> struct node_from_variant_t<594> { using type = SgOmpTaskStatement; };
23906
23907// Class: OmpTaskwaitStatement
23910 using base = SgStatement;
23911 static constexpr char const * const name{"OmpTaskwaitStatement"};
23912 static constexpr unsigned long variant{595};
23913 static constexpr bool concrete{true};
23914 using subclasses_t = mp::List<>;
23915 using fields_t = mp::List<>;
23916};
23917template <> struct node_from_variant_t<595> { using type = SgOmpTaskwaitStatement; };
23918
23919// Class: OmpThreadprivateStatement
23920template <> struct describe_field_t<SgOmpThreadprivateStatement,SgVarRefExpPtrList,&SgOmpThreadprivateStatement::p_variables> {
23922 using field_type = SgVarRefExpPtrList;
23923 static constexpr size_t position{0};
23924 static constexpr char const * const name{"variables"};
23925 static constexpr char const * const typestr{"SgVarRefExpPtrList"};
23926 static constexpr bool traverse{true};
23927 static constexpr auto mbr_ptr{&SgOmpThreadprivateStatement::p_variables};
23928 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
23929 using bind = Desc<SgOmpThreadprivateStatement, SgVarRefExpPtrList SgOmpThreadprivateStatement::*, &SgOmpThreadprivateStatement::p_variables>;
23930};
23934 static constexpr char const * const name{"OmpThreadprivateStatement"};
23935 static constexpr unsigned long variant{596};
23936 static constexpr bool concrete{true};
23937 using subclasses_t = mp::List<>;
23939};
23940template <> struct node_from_variant_t<596> { using type = SgOmpThreadprivateStatement; };
23941
23942// Class: OmpWorkshareStatement
23945 using base = SgOmpBodyStatement;
23946 static constexpr char const * const name{"OmpWorkshareStatement"};
23947 static constexpr unsigned long variant{597};
23948 static constexpr bool concrete{true};
23949 using subclasses_t = mp::List<>;
23950 using fields_t = mp::List<>;
23951};
23952template <> struct node_from_variant_t<597> { using type = SgOmpWorkshareStatement; };
23953
23954// Class: OmpTargetStatement
23956 using node = SgOmpTargetStatement;
23958 static constexpr char const * const name{"OmpTargetStatement"};
23959 static constexpr unsigned long variant{598};
23960 static constexpr bool concrete{true};
23961 using subclasses_t = mp::List<>;
23962 using fields_t = mp::List<>;
23963};
23964template <> struct node_from_variant_t<598> { using type = SgOmpTargetStatement; };
23965
23966// Class: OmpTargetDataStatement
23970 static constexpr char const * const name{"OmpTargetDataStatement"};
23971 static constexpr unsigned long variant{599};
23972 static constexpr bool concrete{true};
23973 using subclasses_t = mp::List<>;
23974 using fields_t = mp::List<>;
23975};
23976template <> struct node_from_variant_t<599> { using type = SgOmpTargetDataStatement; };
23977
23978// Class: OmpSimdStatement
23980 using node = SgOmpSimdStatement;
23982 static constexpr char const * const name{"OmpSimdStatement"};
23983 static constexpr unsigned long variant{600};
23984 static constexpr bool concrete{true};
23985 using subclasses_t = mp::List<>;
23986 using fields_t = mp::List<>;
23987};
23988template <> struct node_from_variant_t<600> { using type = SgOmpSimdStatement; };
23989
23990// Class: OmpClause
23991template <> struct describe_node_t<SgOmpClause> {
23992 using node = SgOmpClause;
23993 using base = SgLocatedNodeSupport;
23994 static constexpr char const * const name{"OmpClause"};
23995 static constexpr unsigned long variant{601};
23996 static constexpr bool concrete{false};
23998 using fields_t = mp::List<>;
23999};
24000template <> struct node_from_variant_t<601> { using type = SgOmpClause; };
24001
24002// Class: OmpBeginClause
24004 using node = SgOmpBeginClause;
24005 using base = SgOmpClause;
24006 static constexpr char const * const name{"OmpBeginClause"};
24007 static constexpr unsigned long variant{602};
24008 static constexpr bool concrete{true};
24009 using subclasses_t = mp::List<>;
24010 using fields_t = mp::List<>;
24011};
24012template <> struct node_from_variant_t<602> { using type = SgOmpBeginClause; };
24013
24014// Class: OmpCollapseClause
24016 using node = SgOmpCollapseClause;
24018 static constexpr char const * const name{"OmpCollapseClause"};
24019 static constexpr unsigned long variant{603};
24020 static constexpr bool concrete{true};
24021 using subclasses_t = mp::List<>;
24022 using fields_t = mp::List<>;
24023};
24024template <> struct node_from_variant_t<603> { using type = SgOmpCollapseClause; };
24025
24026// Class: OmpCopyinClause
24028 using node = SgOmpCopyinClause;
24029 using base = SgOmpVariablesClause;
24030 static constexpr char const * const name{"OmpCopyinClause"};
24031 static constexpr unsigned long variant{604};
24032 static constexpr bool concrete{true};
24033 using subclasses_t = mp::List<>;
24034 using fields_t = mp::List<>;
24035};
24036template <> struct node_from_variant_t<604> { using type = SgOmpCopyinClause; };
24037
24038// Class: OmpCopyprivateClause
24041 using base = SgOmpVariablesClause;
24042 static constexpr char const * const name{"OmpCopyprivateClause"};
24043 static constexpr unsigned long variant{605};
24044 static constexpr bool concrete{true};
24045 using subclasses_t = mp::List<>;
24046 using fields_t = mp::List<>;
24047};
24048template <> struct node_from_variant_t<605> { using type = SgOmpCopyprivateClause; };
24049
24050// Class: OmpDefaultClause
24051template <> struct describe_field_t<SgOmpDefaultClause,SgOmpClause::omp_default_option_enum,&SgOmpDefaultClause::p_data_sharing> {
24052 using parent = SgOmpDefaultClause;
24054 static constexpr size_t position{0};
24055 static constexpr char const * const name{"data_sharing"};
24056 static constexpr char const * const typestr{"SgOmpClause::omp_default_option_enum"};
24057 static constexpr bool traverse{false};
24058 static constexpr auto mbr_ptr{&SgOmpDefaultClause::p_data_sharing};
24059 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
24060 using bind = Desc<SgOmpDefaultClause, SgOmpClause::omp_default_option_enum SgOmpDefaultClause::*, &SgOmpDefaultClause::p_data_sharing>;
24061};
24063 using node = SgOmpDefaultClause;
24064 using base = SgOmpClause;
24065 static constexpr char const * const name{"OmpDefaultClause"};
24066 static constexpr unsigned long variant{606};
24067 static constexpr bool concrete{true};
24068 using subclasses_t = mp::List<>;
24070};
24071template <> struct node_from_variant_t<606> { using type = SgOmpDefaultClause; };
24072
24073// Class: OmpEndClause
24074template <> struct describe_node_t<SgOmpEndClause> {
24075 using node = SgOmpEndClause;
24076 using base = SgOmpClause;
24077 static constexpr char const * const name{"OmpEndClause"};
24078 static constexpr unsigned long variant{607};
24079 static constexpr bool concrete{true};
24080 using subclasses_t = mp::List<>;
24081 using fields_t = mp::List<>;
24082};
24083template <> struct node_from_variant_t<607> { using type = SgOmpEndClause; };
24084
24085// Class: OmpExpressionClause
24086template <> struct describe_field_t<SgOmpExpressionClause,SgExpression*,&SgOmpExpressionClause::p_expression> {
24088 using field_type = SgExpression*;
24089 static constexpr size_t position{0};
24090 static constexpr char const * const name{"expression"};
24091 static constexpr char const * const typestr{"SgExpression*"};
24092 static constexpr bool traverse{true};
24093 static constexpr auto mbr_ptr{&SgOmpExpressionClause::p_expression};
24094 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
24095 using bind = Desc<SgOmpExpressionClause, SgExpression* SgOmpExpressionClause::*, &SgOmpExpressionClause::p_expression>;
24096};
24099 using base = SgOmpClause;
24100 static constexpr char const * const name{"OmpExpressionClause"};
24101 static constexpr unsigned long variant{608};
24102 static constexpr bool concrete{false};
24105};
24106template <> struct node_from_variant_t<608> { using type = SgOmpExpressionClause; };
24107
24108// Class: OmpFirstprivateClause
24111 using base = SgOmpVariablesClause;
24112 static constexpr char const * const name{"OmpFirstprivateClause"};
24113 static constexpr unsigned long variant{609};
24114 static constexpr bool concrete{true};
24115 using subclasses_t = mp::List<>;
24116 using fields_t = mp::List<>;
24117};
24118template <> struct node_from_variant_t<609> { using type = SgOmpFirstprivateClause; };
24119
24120// Class: OmpIfClause
24121template <> struct describe_node_t<SgOmpIfClause> {
24122 using node = SgOmpIfClause;
24124 static constexpr char const * const name{"OmpIfClause"};
24125 static constexpr unsigned long variant{610};
24126 static constexpr bool concrete{true};
24127 using subclasses_t = mp::List<>;
24128 using fields_t = mp::List<>;
24129};
24130template <> struct node_from_variant_t<610> { using type = SgOmpIfClause; };
24131
24132// Class: OmpFinalClause
24134 using node = SgOmpFinalClause;
24136 static constexpr char const * const name{"OmpFinalClause"};
24137 static constexpr unsigned long variant{611};
24138 static constexpr bool concrete{true};
24139 using subclasses_t = mp::List<>;
24140 using fields_t = mp::List<>;
24141};
24142template <> struct node_from_variant_t<611> { using type = SgOmpFinalClause; };
24143
24144// Class: OmpPriorityClause
24146 using node = SgOmpPriorityClause;
24148 static constexpr char const * const name{"OmpPriorityClause"};
24149 static constexpr unsigned long variant{612};
24150 static constexpr bool concrete{true};
24151 using subclasses_t = mp::List<>;
24152 using fields_t = mp::List<>;
24153};
24154template <> struct node_from_variant_t<612> { using type = SgOmpPriorityClause; };
24155
24156// Class: OmpDeviceClause
24158 using node = SgOmpDeviceClause;
24160 static constexpr char const * const name{"OmpDeviceClause"};
24161 static constexpr unsigned long variant{613};
24162 static constexpr bool concrete{true};
24163 using subclasses_t = mp::List<>;
24164 using fields_t = mp::List<>;
24165};
24166template <> struct node_from_variant_t<613> { using type = SgOmpDeviceClause; };
24167
24168// Class: OmpLastprivateClause
24171 using base = SgOmpVariablesClause;
24172 static constexpr char const * const name{"OmpLastprivateClause"};
24173 static constexpr unsigned long variant{614};
24174 static constexpr bool concrete{true};
24175 using subclasses_t = mp::List<>;
24176 using fields_t = mp::List<>;
24177};
24178template <> struct node_from_variant_t<614> { using type = SgOmpLastprivateClause; };
24179
24180// Class: OmpNowaitClause
24182 using node = SgOmpNowaitClause;
24183 using base = SgOmpClause;
24184 static constexpr char const * const name{"OmpNowaitClause"};
24185 static constexpr unsigned long variant{615};
24186 static constexpr bool concrete{true};
24187 using subclasses_t = mp::List<>;
24188 using fields_t = mp::List<>;
24189};
24190template <> struct node_from_variant_t<615> { using type = SgOmpNowaitClause; };
24191
24192// Class: OmpNumThreadsClause
24196 static constexpr char const * const name{"OmpNumThreadsClause"};
24197 static constexpr unsigned long variant{616};
24198 static constexpr bool concrete{true};
24199 using subclasses_t = mp::List<>;
24200 using fields_t = mp::List<>;
24201};
24202template <> struct node_from_variant_t<616> { using type = SgOmpNumThreadsClause; };
24203
24204// Class: OmpOrderedClause
24206 using node = SgOmpOrderedClause;
24208 static constexpr char const * const name{"OmpOrderedClause"};
24209 static constexpr unsigned long variant{617};
24210 static constexpr bool concrete{true};
24211 using subclasses_t = mp::List<>;
24212 using fields_t = mp::List<>;
24213};
24214template <> struct node_from_variant_t<617> { using type = SgOmpOrderedClause; };
24215
24216// Class: OmpPrivateClause
24218 using node = SgOmpPrivateClause;
24219 using base = SgOmpVariablesClause;
24220 static constexpr char const * const name{"OmpPrivateClause"};
24221 static constexpr unsigned long variant{618};
24222 static constexpr bool concrete{true};
24223 using subclasses_t = mp::List<>;
24224 using fields_t = mp::List<>;
24225};
24226template <> struct node_from_variant_t<618> { using type = SgOmpPrivateClause; };
24227
24228// Class: OmpReductionClause
24229template <> struct describe_field_t<SgOmpReductionClause,SgOmpClause::omp_reduction_operator_enum,&SgOmpReductionClause::p_operation> {
24231 using field_type = SgOmpClause::omp_reduction_operator_enum;
24232 static constexpr size_t position{0};
24233 static constexpr char const * const name{"operation"};
24234 static constexpr char const * const typestr{"SgOmpClause::omp_reduction_operator_enum"};
24235 static constexpr bool traverse{false};
24236 static constexpr auto mbr_ptr{&SgOmpReductionClause::p_operation};
24237 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
24238 using bind = Desc<SgOmpReductionClause, SgOmpClause::omp_reduction_operator_enum SgOmpReductionClause::*, &SgOmpReductionClause::p_operation>;
24239};
24241 using node = SgOmpReductionClause;
24242 using base = SgOmpVariablesClause;
24243 static constexpr char const * const name{"OmpReductionClause"};
24244 static constexpr unsigned long variant{619};
24245 static constexpr bool concrete{true};
24246 using subclasses_t = mp::List<>;
24248};
24249template <> struct node_from_variant_t<619> { using type = SgOmpReductionClause; };
24250
24251// Class: OmpScheduleClause
24252template <> struct describe_field_t<SgOmpScheduleClause,SgOmpClause::omp_schedule_kind_enum,&SgOmpScheduleClause::p_kind> {
24254 using field_type = SgOmpClause::omp_schedule_kind_enum;
24255 static constexpr size_t position{0};
24256 static constexpr char const * const name{"kind"};
24257 static constexpr char const * const typestr{"SgOmpClause::omp_schedule_kind_enum"};
24258 static constexpr bool traverse{false};
24259 static constexpr auto mbr_ptr{&SgOmpScheduleClause::p_kind};
24260 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
24261 using bind = Desc<SgOmpScheduleClause, SgOmpClause::omp_schedule_kind_enum SgOmpScheduleClause::*, &SgOmpScheduleClause::p_kind>;
24262};
24263template <> struct describe_field_t<SgOmpScheduleClause,SgExpression*,&SgOmpScheduleClause::p_chunk_size> {
24265 using field_type = SgExpression*;
24266 static constexpr size_t position{1};
24267 static constexpr char const * const name{"chunk_size"};
24268 static constexpr char const * const typestr{"SgExpression*"};
24269 static constexpr bool traverse{true};
24270 static constexpr auto mbr_ptr{&SgOmpScheduleClause::p_chunk_size};
24271 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
24272 using bind = Desc<SgOmpScheduleClause, SgExpression* SgOmpScheduleClause::*, &SgOmpScheduleClause::p_chunk_size>;
24273};
24275 using node = SgOmpScheduleClause;
24276 using base = SgOmpClause;
24277 static constexpr char const * const name{"OmpScheduleClause"};
24278 static constexpr unsigned long variant{620};
24279 static constexpr bool concrete{true};
24280 using subclasses_t = mp::List<>;
24282};
24283template <> struct node_from_variant_t<620> { using type = SgOmpScheduleClause; };
24284
24285// Class: OmpSharedClause
24287 using node = SgOmpSharedClause;
24288 using base = SgOmpVariablesClause;
24289 static constexpr char const * const name{"OmpSharedClause"};
24290 static constexpr unsigned long variant{621};
24291 static constexpr bool concrete{true};
24292 using subclasses_t = mp::List<>;
24293 using fields_t = mp::List<>;
24294};
24295template <> struct node_from_variant_t<621> { using type = SgOmpSharedClause; };
24296
24297// Class: OmpUntiedClause
24299 using node = SgOmpUntiedClause;
24300 using base = SgOmpClause;
24301 static constexpr char const * const name{"OmpUntiedClause"};
24302 static constexpr unsigned long variant{622};
24303 static constexpr bool concrete{true};
24304 using subclasses_t = mp::List<>;
24305 using fields_t = mp::List<>;
24306};
24307template <> struct node_from_variant_t<622> { using type = SgOmpUntiedClause; };
24308
24309// Class: OmpMergeableClause
24311 using node = SgOmpMergeableClause;
24312 using base = SgOmpClause;
24313 static constexpr char const * const name{"OmpMergeableClause"};
24314 static constexpr unsigned long variant{623};
24315 static constexpr bool concrete{true};
24316 using subclasses_t = mp::List<>;
24317 using fields_t = mp::List<>;
24318};
24319template <> struct node_from_variant_t<623> { using type = SgOmpMergeableClause; };
24320
24321// Class: OmpVariablesClause
24322template <> struct describe_field_t<SgOmpVariablesClause,SgExprListExp*,&SgOmpVariablesClause::p_variables> {
24324 using field_type = SgExprListExp*;
24325 static constexpr size_t position{0};
24326 static constexpr char const * const name{"variables"};
24327 static constexpr char const * const typestr{"SgExprListExp*"};
24328 static constexpr bool traverse{true};
24329 static constexpr auto mbr_ptr{&SgOmpVariablesClause::p_variables};
24330 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
24331 using bind = Desc<SgOmpVariablesClause, SgExprListExp* SgOmpVariablesClause::*, &SgOmpVariablesClause::p_variables>;
24332};
24342template <> struct node_from_variant_t<624> { using type = SgOmpVariablesClause; };
24343
24344// Class: OmpMapClause
24345template <> struct describe_field_t<SgOmpMapClause,SgOmpClause::omp_map_operator_enum,&SgOmpMapClause::p_operation> {
24346 using parent = SgOmpMapClause;
24347 using field_type = SgOmpClause::omp_map_operator_enum;
24348 static constexpr size_t position{0};
24349 static constexpr char const * const name{"operation"};
24350 static constexpr char const * const typestr{"SgOmpClause::omp_map_operator_enum"};
24351 static constexpr bool traverse{false};
24352 static constexpr auto mbr_ptr{&SgOmpMapClause::p_operation};
24353 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
24354 using bind = Desc<SgOmpMapClause, SgOmpClause::omp_map_operator_enum SgOmpMapClause::*, &SgOmpMapClause::p_operation>;
24355};
24356template <> struct describe_field_t<SgOmpMapClause,std::map<SgSymbol*, std::vector < std::pair <SgExpression*, SgExpression*> > >,&SgOmpMapClause::p_array_dimensions> {
24357 using parent = SgOmpMapClause;
24358 using field_type = std::map<SgSymbol*, std::vector < std::pair <SgExpression*, SgExpression*> > >;
24359 static constexpr size_t position{1};
24360 static constexpr char const * const name{"array_dimensions"};
24361 static constexpr char const * const typestr{"std::map<SgSymbol*, std::vector < std::pair <SgExpression*, SgExpression*> > >"};
24362 static constexpr bool traverse{false};
24363 static constexpr auto mbr_ptr{&SgOmpMapClause::p_array_dimensions};
24364 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
24365 using bind = Desc<SgOmpMapClause, std::map<SgSymbol*, std::vector < std::pair <SgExpression*, SgExpression*> > > SgOmpMapClause::*, &SgOmpMapClause::p_array_dimensions>;
24366};
24367template <> struct describe_field_t<SgOmpMapClause,std::map<SgSymbol*, std::vector < std::pair <SgOmpClause::omp_map_dist_data_enum, SgExpression*> > >,&SgOmpMapClause::p_dist_data_policies> {
24368 using parent = SgOmpMapClause;
24369 using field_type = std::map<SgSymbol*, std::vector < std::pair <SgOmpClause::omp_map_dist_data_enum, SgExpression*> > >;
24370 static constexpr size_t position{2};
24371 static constexpr char const * const name{"dist_data_policies"};
24372 static constexpr char const * const typestr{"std::map<SgSymbol*, std::vector < std::pair <SgOmpClause::omp_map_dist_data_enum, SgExpression*> > >"};
24373 static constexpr bool traverse{false};
24374 static constexpr auto mbr_ptr{&SgOmpMapClause::p_dist_data_policies};
24375 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
24376 using bind = Desc<SgOmpMapClause, std::map<SgSymbol*, std::vector < std::pair <SgOmpClause::omp_map_dist_data_enum, SgExpression*> > > SgOmpMapClause::*, &SgOmpMapClause::p_dist_data_policies>;
24377};
24378template <> struct describe_node_t<SgOmpMapClause> {
24379 using node = SgOmpMapClause;
24380 using base = SgOmpVariablesClause;
24381 static constexpr char const * const name{"OmpMapClause"};
24382 static constexpr unsigned long variant{625};
24383 static constexpr bool concrete{true};
24384 using subclasses_t = mp::List<>;
24386};
24387template <> struct node_from_variant_t<625> { using type = SgOmpMapClause; };
24388
24389// Class: OmpSafelenClause
24391 using node = SgOmpSafelenClause;
24393 static constexpr char const * const name{"OmpSafelenClause"};
24394 static constexpr unsigned long variant{626};
24395 static constexpr bool concrete{true};
24396 using subclasses_t = mp::List<>;
24397 using fields_t = mp::List<>;
24398};
24399template <> struct node_from_variant_t<626> { using type = SgOmpSafelenClause; };
24400
24401// Class: OmpSimdlenClause
24403 using node = SgOmpSimdlenClause;
24405 static constexpr char const * const name{"OmpSimdlenClause"};
24406 static constexpr unsigned long variant{627};
24407 static constexpr bool concrete{true};
24408 using subclasses_t = mp::List<>;
24409 using fields_t = mp::List<>;
24410};
24411template <> struct node_from_variant_t<627> { using type = SgOmpSimdlenClause; };
24412
24413// Class: OmpLinearClause
24414template <> struct describe_field_t<SgOmpLinearClause,SgExpression*,&SgOmpLinearClause::p_step> {
24415 using parent = SgOmpLinearClause;
24416 using field_type = SgExpression*;
24417 static constexpr size_t position{0};
24418 static constexpr char const * const name{"step"};
24419 static constexpr char const * const typestr{"SgExpression*"};
24420 static constexpr bool traverse{true};
24421 static constexpr auto mbr_ptr{&SgOmpLinearClause::p_step};
24422 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
24423 using bind = Desc<SgOmpLinearClause, SgExpression* SgOmpLinearClause::*, &SgOmpLinearClause::p_step>;
24424};
24426 using node = SgOmpLinearClause;
24427 using base = SgOmpVariablesClause;
24428 static constexpr char const * const name{"OmpLinearClause"};
24429 static constexpr unsigned long variant{628};
24430 static constexpr bool concrete{true};
24431 using subclasses_t = mp::List<>;
24433};
24434template <> struct node_from_variant_t<628> { using type = SgOmpLinearClause; };
24435
24436// Class: OmpUniformClause
24438 using node = SgOmpUniformClause;
24439 using base = SgOmpVariablesClause;
24440 static constexpr char const * const name{"OmpUniformClause"};
24441 static constexpr unsigned long variant{629};
24442 static constexpr bool concrete{true};
24443 using subclasses_t = mp::List<>;
24444 using fields_t = mp::List<>;
24445};
24446template <> struct node_from_variant_t<629> { using type = SgOmpUniformClause; };
24447
24448// Class: OmpAlignedClause
24449template <> struct describe_field_t<SgOmpAlignedClause,SgExpression*,&SgOmpAlignedClause::p_alignment> {
24450 using parent = SgOmpAlignedClause;
24451 using field_type = SgExpression*;
24452 static constexpr size_t position{0};
24453 static constexpr char const * const name{"alignment"};
24454 static constexpr char const * const typestr{"SgExpression*"};
24455 static constexpr bool traverse{true};
24456 static constexpr auto mbr_ptr{&SgOmpAlignedClause::p_alignment};
24457 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
24458 using bind = Desc<SgOmpAlignedClause, SgExpression* SgOmpAlignedClause::*, &SgOmpAlignedClause::p_alignment>;
24459};
24461 using node = SgOmpAlignedClause;
24462 using base = SgOmpVariablesClause;
24463 static constexpr char const * const name{"OmpAlignedClause"};
24464 static constexpr unsigned long variant{630};
24465 static constexpr bool concrete{true};
24466 using subclasses_t = mp::List<>;
24468};
24469template <> struct node_from_variant_t<630> { using type = SgOmpAlignedClause; };
24470
24471// Class: OmpProcBindClause
24472template <> struct describe_field_t<SgOmpProcBindClause,SgOmpClause::omp_proc_bind_policy_enum,&SgOmpProcBindClause::p_policy> {
24474 using field_type = SgOmpClause::omp_proc_bind_policy_enum;
24475 static constexpr size_t position{0};
24476 static constexpr char const * const name{"policy"};
24477 static constexpr char const * const typestr{"SgOmpClause::omp_proc_bind_policy_enum"};
24478 static constexpr bool traverse{false};
24479 static constexpr auto mbr_ptr{&SgOmpProcBindClause::p_policy};
24480 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
24481 using bind = Desc<SgOmpProcBindClause, SgOmpClause::omp_proc_bind_policy_enum SgOmpProcBindClause::*, &SgOmpProcBindClause::p_policy>;
24482};
24484 using node = SgOmpProcBindClause;
24485 using base = SgOmpClause;
24486 static constexpr char const * const name{"OmpProcBindClause"};
24487 static constexpr unsigned long variant{631};
24488 static constexpr bool concrete{true};
24489 using subclasses_t = mp::List<>;
24491};
24492template <> struct node_from_variant_t<631> { using type = SgOmpProcBindClause; };
24493
24494// Class: OmpAtomicClause
24495template <> struct describe_field_t<SgOmpAtomicClause,SgOmpClause::omp_atomic_clause_enum,&SgOmpAtomicClause::p_atomicity> {
24496 using parent = SgOmpAtomicClause;
24497 using field_type = SgOmpClause::omp_atomic_clause_enum;
24498 static constexpr size_t position{0};
24499 static constexpr char const * const name{"atomicity"};
24500 static constexpr char const * const typestr{"SgOmpClause::omp_atomic_clause_enum"};
24501 static constexpr bool traverse{false};
24502 static constexpr auto mbr_ptr{&SgOmpAtomicClause::p_atomicity};
24503 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
24504 using bind = Desc<SgOmpAtomicClause, SgOmpClause::omp_atomic_clause_enum SgOmpAtomicClause::*, &SgOmpAtomicClause::p_atomicity>;
24505};
24507 using node = SgOmpAtomicClause;
24508 using base = SgOmpClause;
24509 static constexpr char const * const name{"OmpAtomicClause"};
24510 static constexpr unsigned long variant{632};
24511 static constexpr bool concrete{true};
24512 using subclasses_t = mp::List<>;
24514};
24515template <> struct node_from_variant_t<632> { using type = SgOmpAtomicClause; };
24516
24517// Class: OmpInbranchClause
24519 using node = SgOmpInbranchClause;
24520 using base = SgOmpClause;
24521 static constexpr char const * const name{"OmpInbranchClause"};
24522 static constexpr unsigned long variant{633};
24523 static constexpr bool concrete{true};
24524 using subclasses_t = mp::List<>;
24525 using fields_t = mp::List<>;
24526};
24527template <> struct node_from_variant_t<633> { using type = SgOmpInbranchClause; };
24528
24529// Class: OmpNotinbranchClause
24532 using base = SgOmpClause;
24533 static constexpr char const * const name{"OmpNotinbranchClause"};
24534 static constexpr unsigned long variant{634};
24535 static constexpr bool concrete{true};
24536 using subclasses_t = mp::List<>;
24537 using fields_t = mp::List<>;
24538};
24539template <> struct node_from_variant_t<634> { using type = SgOmpNotinbranchClause; };
24540
24541// Class: OmpDependClause
24542template <> struct describe_field_t<SgOmpDependClause,SgOmpClause::omp_dependence_type_enum,&SgOmpDependClause::p_dependence_type> {
24543 using parent = SgOmpDependClause;
24544 using field_type = SgOmpClause::omp_dependence_type_enum;
24545 static constexpr size_t position{0};
24546 static constexpr char const * const name{"dependence_type"};
24547 static constexpr char const * const typestr{"SgOmpClause::omp_dependence_type_enum"};
24548 static constexpr bool traverse{false};
24549 static constexpr auto mbr_ptr{&SgOmpDependClause::p_dependence_type};
24550 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
24551 using bind = Desc<SgOmpDependClause, SgOmpClause::omp_dependence_type_enum SgOmpDependClause::*, &SgOmpDependClause::p_dependence_type>;
24552};
24553template <> struct describe_field_t<SgOmpDependClause,std::map<SgSymbol*, std::vector < std::pair <SgExpression*, SgExpression*> > >,&SgOmpDependClause::p_array_dimensions> {
24554 using parent = SgOmpDependClause;
24555 using field_type = std::map<SgSymbol*, std::vector < std::pair <SgExpression*, SgExpression*> > >;
24556 static constexpr size_t position{1};
24557 static constexpr char const * const name{"array_dimensions"};
24558 static constexpr char const * const typestr{"std::map<SgSymbol*, std::vector < std::pair <SgExpression*, SgExpression*> > >"};
24559 static constexpr bool traverse{false};
24560 static constexpr auto mbr_ptr{&SgOmpDependClause::p_array_dimensions};
24561 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
24562 using bind = Desc<SgOmpDependClause, std::map<SgSymbol*, std::vector < std::pair <SgExpression*, SgExpression*> > > SgOmpDependClause::*, &SgOmpDependClause::p_array_dimensions>;
24563};
24565 using node = SgOmpDependClause;
24566 using base = SgOmpVariablesClause;
24567 static constexpr char const * const name{"OmpDependClause"};
24568 static constexpr unsigned long variant{635};
24569 static constexpr bool concrete{true};
24570 using subclasses_t = mp::List<>;
24572};
24573template <> struct node_from_variant_t<635> { using type = SgOmpDependClause; };
24574
24575// Class: OpenclAccessModeModifier
24576template <> struct describe_field_t<SgOpenclAccessModeModifier,SgOpenclAccessModeModifier::access_mode_modifier_enum,&SgOpenclAccessModeModifier::p_modifier> {
24579 static constexpr size_t position{0};
24580 static constexpr char const * const name{"modifier"};
24581 static constexpr char const * const typestr{"SgOpenclAccessModeModifier::access_mode_modifier_enum"};
24582 static constexpr bool traverse{false};
24583 static constexpr auto mbr_ptr{&SgOpenclAccessModeModifier::p_modifier};
24584 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
24585 using bind = Desc<SgOpenclAccessModeModifier, SgOpenclAccessModeModifier::access_mode_modifier_enum SgOpenclAccessModeModifier::*, &SgOpenclAccessModeModifier::p_modifier>;
24586};
24589 using base = SgModifier;
24590 static constexpr char const * const name{"OpenclAccessModeModifier"};
24591 static constexpr unsigned long variant{636};
24592 static constexpr bool concrete{true};
24593 using subclasses_t = mp::List<>;
24595};
24596template <> struct node_from_variant_t<636> { using type = SgOpenclAccessModeModifier; };
24597
24598// Class: OpenStatement
24599template <> struct describe_field_t<SgOpenStatement,SgExpression*,&SgOpenStatement::p_file> {
24600 using parent = SgOpenStatement;
24601 using field_type = SgExpression*;
24602 static constexpr size_t position{0};
24603 static constexpr char const * const name{"file"};
24604 static constexpr char const * const typestr{"SgExpression*"};
24605 static constexpr bool traverse{true};
24606 static constexpr auto mbr_ptr{&SgOpenStatement::p_file};
24607 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
24608 using bind = Desc<SgOpenStatement, SgExpression* SgOpenStatement::*, &SgOpenStatement::p_file>;
24609};
24610template <> struct describe_field_t<SgOpenStatement,SgExpression*,&SgOpenStatement::p_status> {
24611 using parent = SgOpenStatement;
24612 using field_type = SgExpression*;
24613 static constexpr size_t position{1};
24614 static constexpr char const * const name{"status"};
24615 static constexpr char const * const typestr{"SgExpression*"};
24616 static constexpr bool traverse{true};
24617 static constexpr auto mbr_ptr{&SgOpenStatement::p_status};
24618 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
24619 using bind = Desc<SgOpenStatement, SgExpression* SgOpenStatement::*, &SgOpenStatement::p_status>;
24620};
24621template <> struct describe_field_t<SgOpenStatement,SgExpression*,&SgOpenStatement::p_access> {
24622 using parent = SgOpenStatement;
24623 using field_type = SgExpression*;
24624 static constexpr size_t position{2};
24625 static constexpr char const * const name{"access"};
24626 static constexpr char const * const typestr{"SgExpression*"};
24627 static constexpr bool traverse{true};
24628 static constexpr auto mbr_ptr{&SgOpenStatement::p_access};
24629 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
24630 using bind = Desc<SgOpenStatement, SgExpression* SgOpenStatement::*, &SgOpenStatement::p_access>;
24631};
24632template <> struct describe_field_t<SgOpenStatement,SgExpression*,&SgOpenStatement::p_form> {
24633 using parent = SgOpenStatement;
24634 using field_type = SgExpression*;
24635 static constexpr size_t position{3};
24636 static constexpr char const * const name{"form"};
24637 static constexpr char const * const typestr{"SgExpression*"};
24638 static constexpr bool traverse{true};
24639 static constexpr auto mbr_ptr{&SgOpenStatement::p_form};
24640 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
24641 using bind = Desc<SgOpenStatement, SgExpression* SgOpenStatement::*, &SgOpenStatement::p_form>;
24642};
24643template <> struct describe_field_t<SgOpenStatement,SgExpression*,&SgOpenStatement::p_recl> {
24644 using parent = SgOpenStatement;
24645 using field_type = SgExpression*;
24646 static constexpr size_t position{4};
24647 static constexpr char const * const name{"recl"};
24648 static constexpr char const * const typestr{"SgExpression*"};
24649 static constexpr bool traverse{true};
24650 static constexpr auto mbr_ptr{&SgOpenStatement::p_recl};
24651 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
24652 using bind = Desc<SgOpenStatement, SgExpression* SgOpenStatement::*, &SgOpenStatement::p_recl>;
24653};
24654template <> struct describe_field_t<SgOpenStatement,SgExpression*,&SgOpenStatement::p_blank> {
24655 using parent = SgOpenStatement;
24656 using field_type = SgExpression*;
24657 static constexpr size_t position{5};
24658 static constexpr char const * const name{"blank"};
24659 static constexpr char const * const typestr{"SgExpression*"};
24660 static constexpr bool traverse{true};
24661 static constexpr auto mbr_ptr{&SgOpenStatement::p_blank};
24662 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
24663 using bind = Desc<SgOpenStatement, SgExpression* SgOpenStatement::*, &SgOpenStatement::p_blank>;
24664};
24665template <> struct describe_field_t<SgOpenStatement,SgExpression*,&SgOpenStatement::p_position> {
24666 using parent = SgOpenStatement;
24667 using field_type = SgExpression*;
24668 static constexpr size_t position{6};
24669 static constexpr char const * const name{"position"};
24670 static constexpr char const * const typestr{"SgExpression*"};
24671 static constexpr bool traverse{true};
24672 static constexpr auto mbr_ptr{&SgOpenStatement::p_position};
24673 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
24674 using bind = Desc<SgOpenStatement, SgExpression* SgOpenStatement::*, &SgOpenStatement::p_position>;
24675};
24676template <> struct describe_field_t<SgOpenStatement,SgExpression*,&SgOpenStatement::p_action> {
24677 using parent = SgOpenStatement;
24678 using field_type = SgExpression*;
24679 static constexpr size_t position{7};
24680 static constexpr char const * const name{"action"};
24681 static constexpr char const * const typestr{"SgExpression*"};
24682 static constexpr bool traverse{true};
24683 static constexpr auto mbr_ptr{&SgOpenStatement::p_action};
24684 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
24685 using bind = Desc<SgOpenStatement, SgExpression* SgOpenStatement::*, &SgOpenStatement::p_action>;
24686};
24687template <> struct describe_field_t<SgOpenStatement,SgExpression*,&SgOpenStatement::p_delim> {
24688 using parent = SgOpenStatement;
24689 using field_type = SgExpression*;
24690 static constexpr size_t position{8};
24691 static constexpr char const * const name{"delim"};
24692 static constexpr char const * const typestr{"SgExpression*"};
24693 static constexpr bool traverse{true};
24694 static constexpr auto mbr_ptr{&SgOpenStatement::p_delim};
24695 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
24696 using bind = Desc<SgOpenStatement, SgExpression* SgOpenStatement::*, &SgOpenStatement::p_delim>;
24697};
24698template <> struct describe_field_t<SgOpenStatement,SgExpression*,&SgOpenStatement::p_pad> {
24699 using parent = SgOpenStatement;
24700 using field_type = SgExpression*;
24701 static constexpr size_t position{9};
24702 static constexpr char const * const name{"pad"};
24703 static constexpr char const * const typestr{"SgExpression*"};
24704 static constexpr bool traverse{true};
24705 static constexpr auto mbr_ptr{&SgOpenStatement::p_pad};
24706 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
24707 using bind = Desc<SgOpenStatement, SgExpression* SgOpenStatement::*, &SgOpenStatement::p_pad>;
24708};
24709template <> struct describe_field_t<SgOpenStatement,SgExpression*,&SgOpenStatement::p_round> {
24710 using parent = SgOpenStatement;
24711 using field_type = SgExpression*;
24712 static constexpr size_t position{10};
24713 static constexpr char const * const name{"round"};
24714 static constexpr char const * const typestr{"SgExpression*"};
24715 static constexpr bool traverse{true};
24716 static constexpr auto mbr_ptr{&SgOpenStatement::p_round};
24717 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
24718 using bind = Desc<SgOpenStatement, SgExpression* SgOpenStatement::*, &SgOpenStatement::p_round>;
24719};
24720template <> struct describe_field_t<SgOpenStatement,SgExpression*,&SgOpenStatement::p_sign> {
24721 using parent = SgOpenStatement;
24722 using field_type = SgExpression*;
24723 static constexpr size_t position{11};
24724 static constexpr char const * const name{"sign"};
24725 static constexpr char const * const typestr{"SgExpression*"};
24726 static constexpr bool traverse{true};
24727 static constexpr auto mbr_ptr{&SgOpenStatement::p_sign};
24728 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
24729 using bind = Desc<SgOpenStatement, SgExpression* SgOpenStatement::*, &SgOpenStatement::p_sign>;
24730};
24731template <> struct describe_field_t<SgOpenStatement,SgExpression*,&SgOpenStatement::p_asynchronous> {
24732 using parent = SgOpenStatement;
24733 using field_type = SgExpression*;
24734 static constexpr size_t position{12};
24735 static constexpr char const * const name{"asynchronous"};
24736 static constexpr char const * const typestr{"SgExpression*"};
24737 static constexpr bool traverse{true};
24738 static constexpr auto mbr_ptr{&SgOpenStatement::p_asynchronous};
24739 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
24740 using bind = Desc<SgOpenStatement, SgExpression* SgOpenStatement::*, &SgOpenStatement::p_asynchronous>;
24741};
24751template <> struct node_from_variant_t<637> { using type = SgOpenStatement; };
24752
24753// Class: Options
24754template <> struct describe_field_t<SgOptions,std::ostream*,&SgOptions::p_default_output> {
24755 using parent = SgOptions;
24756 using field_type = std::ostream*;
24757 static constexpr size_t position{0};
24758 static constexpr char const * const name{"default_output"};
24759 static constexpr char const * const typestr{"std::ostream*"};
24760 static constexpr bool traverse{false};
24761 static constexpr auto mbr_ptr{&SgOptions::p_default_output};
24762 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
24763 using bind = Desc<SgOptions, std::ostream* SgOptions::*, &SgOptions::p_default_output>;
24764};
24765template <> struct describe_field_t<SgOptions,std::ostream*,&SgOptions::p_debug_output> {
24766 using parent = SgOptions;
24767 using field_type = std::ostream*;
24768 static constexpr size_t position{1};
24769 static constexpr char const * const name{"debug_output"};
24770 static constexpr char const * const typestr{"std::ostream*"};
24771 static constexpr bool traverse{false};
24772 static constexpr auto mbr_ptr{&SgOptions::p_debug_output};
24773 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
24774 using bind = Desc<SgOptions, std::ostream* SgOptions::*, &SgOptions::p_debug_output>;
24775};
24776template <> struct describe_field_t<SgOptions,std::ostream*,&SgOptions::p_error_output> {
24777 using parent = SgOptions;
24778 using field_type = std::ostream*;
24779 static constexpr size_t position{2};
24780 static constexpr char const * const name{"error_output"};
24781 static constexpr char const * const typestr{"std::ostream*"};
24782 static constexpr bool traverse{false};
24783 static constexpr auto mbr_ptr{&SgOptions::p_error_output};
24784 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
24785 using bind = Desc<SgOptions, std::ostream* SgOptions::*, &SgOptions::p_error_output>;
24786};
24787template <> struct describe_field_t<SgOptions,std::ostream*,&SgOptions::p_logging_output> {
24788 using parent = SgOptions;
24789 using field_type = std::ostream*;
24790 static constexpr size_t position{3};
24791 static constexpr char const * const name{"logging_output"};
24792 static constexpr char const * const typestr{"std::ostream*"};
24793 static constexpr bool traverse{false};
24794 static constexpr auto mbr_ptr{&SgOptions::p_logging_output};
24795 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
24796 using bind = Desc<SgOptions, std::ostream* SgOptions::*, &SgOptions::p_logging_output>;
24797};
24798template <> struct describe_field_t<SgOptions,int,&SgOptions::p_debug_level> {
24799 using parent = SgOptions;
24800 using field_type = int;
24801 static constexpr size_t position{4};
24802 static constexpr char const * const name{"debug_level"};
24803 static constexpr char const * const typestr{"int"};
24804 static constexpr bool traverse{false};
24805 static constexpr auto mbr_ptr{&SgOptions::p_debug_level};
24806 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
24807 using bind = Desc<SgOptions, int SgOptions::*, &SgOptions::p_debug_level>;
24808};
24809template <> struct describe_field_t<SgOptions,int,&SgOptions::p_logging_level> {
24810 using parent = SgOptions;
24811 using field_type = int;
24812 static constexpr size_t position{5};
24813 static constexpr char const * const name{"logging_level"};
24814 static constexpr char const * const typestr{"int"};
24815 static constexpr bool traverse{false};
24816 static constexpr auto mbr_ptr{&SgOptions::p_logging_level};
24817 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
24818 using bind = Desc<SgOptions, int SgOptions::*, &SgOptions::p_logging_level>;
24819};
24829template <> struct node_from_variant_t<638> { using type = SgOptions; };
24830
24831// Class: OrOp
24832template <> struct describe_node_t<SgOrOp> {
24833 using node = SgOrOp;
24834 using base = SgBinaryOp;
24835 static constexpr char const * const name{"OrOp"};
24836 static constexpr unsigned long variant{639};
24837 static constexpr bool concrete{true};
24838 using subclasses_t = mp::List<>;
24839 using fields_t = mp::List<>;
24840};
24841template <> struct node_from_variant_t<639> { using type = SgOrOp; };
24842
24843// Class: ParameterStatement
24845 using node = SgParameterStatement;
24847 static constexpr char const * const name{"ParameterStatement"};
24848 static constexpr unsigned long variant{640};
24849 static constexpr bool concrete{true};
24850 using subclasses_t = mp::List<>;
24851 using fields_t = mp::List<>;
24852};
24853template <> struct node_from_variant_t<640> { using type = SgParameterStatement; };
24854
24855// Class: PartialFunctionModifierType
24859 static constexpr char const * const name{"PartialFunctionModifierType"};
24860 static constexpr unsigned long variant{641};
24861 static constexpr bool concrete{true};
24862 using subclasses_t = mp::List<>;
24863 using fields_t = mp::List<>;
24864};
24865template <> struct node_from_variant_t<641> { using type = SgPartialFunctionModifierType; };
24866
24867// Class: PartialFunctionType
24870 using base = SgMemberFunctionType;
24871 static constexpr char const * const name{"PartialFunctionType"};
24872 static constexpr unsigned long variant{642};
24873 static constexpr bool concrete{true};
24875 using fields_t = mp::List<>;
24876};
24877template <> struct node_from_variant_t<642> { using type = SgPartialFunctionType; };
24878
24879// Class: PassStatement
24881 using node = SgPassStatement;
24882 using base = SgStatement;
24883 static constexpr char const * const name{"PassStatement"};
24884 static constexpr unsigned long variant{643};
24885 static constexpr bool concrete{true};
24886 using subclasses_t = mp::List<>;
24887 using fields_t = mp::List<>;
24888};
24889template <> struct node_from_variant_t<643> { using type = SgPassStatement; };
24890
24891// Class: PlusAssignOp
24892template <> struct describe_node_t<SgPlusAssignOp> {
24893 using node = SgPlusAssignOp;
24894 using base = SgCompoundAssignOp;
24895 static constexpr char const * const name{"PlusAssignOp"};
24896 static constexpr unsigned long variant{644};
24897 static constexpr bool concrete{true};
24898 using subclasses_t = mp::List<>;
24899 using fields_t = mp::List<>;
24900};
24901template <> struct node_from_variant_t<644> { using type = SgPlusAssignOp; };
24902
24903// Class: PlusPlusOp
24904template <> struct describe_node_t<SgPlusPlusOp> {
24905 using node = SgPlusPlusOp;
24906 using base = SgUnaryOp;
24907 static constexpr char const * const name{"PlusPlusOp"};
24908 static constexpr unsigned long variant{645};
24909 static constexpr bool concrete{true};
24910 using subclasses_t = mp::List<>;
24911 using fields_t = mp::List<>;
24912};
24913template <> struct node_from_variant_t<645> { using type = SgPlusPlusOp; };
24914
24915// Class: PntrArrRefExp
24917 using node = SgPntrArrRefExp;
24918 using base = SgBinaryOp;
24919 static constexpr char const * const name{"PntrArrRefExp"};
24920 static constexpr unsigned long variant{646};
24921 static constexpr bool concrete{true};
24922 using subclasses_t = mp::List<>;
24923 using fields_t = mp::List<>;
24924};
24925template <> struct node_from_variant_t<646> { using type = SgPntrArrRefExp; };
24926
24927// Class: PointerAssignOp
24929 using node = SgPointerAssignOp;
24930 using base = SgBinaryOp;
24931 static constexpr char const * const name{"PointerAssignOp"};
24932 static constexpr unsigned long variant{647};
24933 static constexpr bool concrete{true};
24934 using subclasses_t = mp::List<>;
24935 using fields_t = mp::List<>;
24936};
24937template <> struct node_from_variant_t<647> { using type = SgPointerAssignOp; };
24938
24939// Class: PointerDerefExp
24941 using node = SgPointerDerefExp;
24942 using base = SgUnaryOp;
24943 static constexpr char const * const name{"PointerDerefExp"};
24944 static constexpr unsigned long variant{648};
24945 static constexpr bool concrete{true};
24946 using subclasses_t = mp::List<>;
24947 using fields_t = mp::List<>;
24948};
24949template <> struct node_from_variant_t<648> { using type = SgPointerDerefExp; };
24950
24951// Class: PointerMemberType
24952template <> struct describe_field_t<SgPointerMemberType,SgType*,&SgPointerMemberType::p_class_type> {
24954 using field_type = SgType*;
24955 static constexpr size_t position{0};
24956 static constexpr char const * const name{"class_type"};
24957 static constexpr char const * const typestr{"SgType*"};
24958 static constexpr bool traverse{false};
24959 static constexpr auto mbr_ptr{&SgPointerMemberType::p_class_type};
24960 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
24961 using bind = Desc<SgPointerMemberType, SgType* SgPointerMemberType::*, &SgPointerMemberType::p_class_type>;
24962};
24964 using node = SgPointerMemberType;
24965 using base = SgPointerType;
24966 static constexpr char const * const name{"PointerMemberType"};
24967 static constexpr unsigned long variant{649};
24968 static constexpr bool concrete{true};
24969 using subclasses_t = mp::List<>;
24971};
24972template <> struct node_from_variant_t<649> { using type = SgPointerMemberType; };
24973
24974// Class: PointerType
24975template <> struct describe_field_t<SgPointerType,SgType*,&SgPointerType::p_base_type> {
24976 using parent = SgPointerType;
24977 using field_type = SgType*;
24978 static constexpr size_t position{0};
24979 static constexpr char const * const name{"base_type"};
24980 static constexpr char const * const typestr{"SgType*"};
24981 static constexpr bool traverse{true};
24982 static constexpr auto mbr_ptr{&SgPointerType::p_base_type};
24983 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
24984 using bind = Desc<SgPointerType, SgType* SgPointerType::*, &SgPointerType::p_base_type>;
24985};
24986template <> struct describe_node_t<SgPointerType> {
24987 using node = SgPointerType;
24988 using base = SgType;
24989 static constexpr char const * const name{"PointerType"};
24990 static constexpr unsigned long variant{650};
24991 static constexpr bool concrete{true};
24994};
24995template <> struct node_from_variant_t<650> { using type = SgPointerType; };
24996
24997// Class: PowerOp
24998template <> struct describe_node_t<SgPowerOp> {
24999 using node = SgPowerOp;
25000 using base = SgBinaryOp;
25001 static constexpr char const * const name{"PowerOp"};
25002 static constexpr unsigned long variant{651};
25003 static constexpr bool concrete{true};
25004 using subclasses_t = mp::List<>;
25005 using fields_t = mp::List<>;
25006};
25007template <> struct node_from_variant_t<651> { using type = SgPowerOp; };
25008
25009// Class: Pragma
25010template <> struct describe_field_t<SgPragma,Sg_File_Info*,&SgPragma::p_startOfConstruct> {
25011 using parent = SgPragma;
25012 using field_type = Sg_File_Info*;
25013 static constexpr size_t position{0};
25014 static constexpr char const * const name{"startOfConstruct"};
25015 static constexpr char const * const typestr{"Sg_File_Info*"};
25016 static constexpr bool traverse{false};
25017 static constexpr auto mbr_ptr{&SgPragma::p_startOfConstruct};
25018 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25019 using bind = Desc<SgPragma, Sg_File_Info* SgPragma::*, &SgPragma::p_startOfConstruct>;
25020};
25021template <> struct describe_field_t<SgPragma,Sg_File_Info*,&SgPragma::p_endOfConstruct> {
25022 using parent = SgPragma;
25023 using field_type = Sg_File_Info*;
25024 static constexpr size_t position{1};
25025 static constexpr char const * const name{"endOfConstruct"};
25026 static constexpr char const * const typestr{"Sg_File_Info*"};
25027 static constexpr bool traverse{false};
25028 static constexpr auto mbr_ptr{&SgPragma::p_endOfConstruct};
25029 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25030 using bind = Desc<SgPragma, Sg_File_Info* SgPragma::*, &SgPragma::p_endOfConstruct>;
25031};
25032template <> struct describe_field_t<SgPragma,short,&SgPragma::p_printed> {
25033 using parent = SgPragma;
25034 using field_type = short;
25035 static constexpr size_t position{2};
25036 static constexpr char const * const name{"printed"};
25037 static constexpr char const * const typestr{"short"};
25038 static constexpr bool traverse{false};
25039 static constexpr auto mbr_ptr{&SgPragma::p_printed};
25040 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25041 using bind = Desc<SgPragma, short SgPragma::*, &SgPragma::p_printed>;
25042};
25043template <> struct describe_field_t<SgPragma,SgExprListExp*,&SgPragma::p_args> {
25044 using parent = SgPragma;
25045 using field_type = SgExprListExp*;
25046 static constexpr size_t position{3};
25047 static constexpr char const * const name{"args"};
25048 static constexpr char const * const typestr{"SgExprListExp*"};
25049 static constexpr bool traverse{false};
25050 static constexpr auto mbr_ptr{&SgPragma::p_args};
25051 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25052 using bind = Desc<SgPragma, SgExprListExp* SgPragma::*, &SgPragma::p_args>;
25053};
25054template <> struct describe_field_t<SgPragma,SgStatement*,&SgPragma::p_associatedStatement> {
25055 using parent = SgPragma;
25056 using field_type = SgStatement*;
25057 static constexpr size_t position{4};
25058 static constexpr char const * const name{"associatedStatement"};
25059 static constexpr char const * const typestr{"SgStatement*"};
25060 static constexpr bool traverse{false};
25061 static constexpr auto mbr_ptr{&SgPragma::p_associatedStatement};
25062 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25063 using bind = Desc<SgPragma, SgStatement* SgPragma::*, &SgPragma::p_associatedStatement>;
25064};
25065template <> struct describe_field_t<SgPragma,AstAttributeMechanism*,&SgPragma::p_attributeMechanism> {
25066 using parent = SgPragma;
25068 static constexpr size_t position{5};
25069 static constexpr char const * const name{"attributeMechanism"};
25070 static constexpr char const * const typestr{"AstAttributeMechanism*"};
25071 static constexpr bool traverse{false};
25072 static constexpr auto mbr_ptr{&SgPragma::p_attributeMechanism};
25073 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25074 using bind = Desc<SgPragma, AstAttributeMechanism* SgPragma::*, &SgPragma::p_attributeMechanism>;
25075};
25085template <> struct node_from_variant_t<652> { using type = SgPragma; };
25086
25087// Class: PragmaDeclaration
25088template <> struct describe_field_t<SgPragmaDeclaration,SgPragma*,&SgPragmaDeclaration::p_pragma> {
25090 using field_type = SgPragma*;
25091 static constexpr size_t position{0};
25092 static constexpr char const * const name{"pragma"};
25093 static constexpr char const * const typestr{"SgPragma*"};
25094 static constexpr bool traverse{true};
25095 static constexpr auto mbr_ptr{&SgPragmaDeclaration::p_pragma};
25096 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25097 using bind = Desc<SgPragmaDeclaration, SgPragma* SgPragmaDeclaration::*, &SgPragmaDeclaration::p_pragma>;
25098};
25100 using node = SgPragmaDeclaration;
25102 static constexpr char const * const name{"PragmaDeclaration"};
25103 static constexpr unsigned long variant{653};
25104 static constexpr bool concrete{true};
25105 using subclasses_t = mp::List<>;
25107};
25108template <> struct node_from_variant_t<653> { using type = SgPragmaDeclaration; };
25109
25110// Class: PrintStatement
25111template <> struct describe_field_t<SgPrintStatement,SgExpression*,&SgPrintStatement::p_format> {
25112 using parent = SgPrintStatement;
25113 using field_type = SgExpression*;
25114 static constexpr size_t position{0};
25115 static constexpr char const * const name{"format"};
25116 static constexpr char const * const typestr{"SgExpression*"};
25117 static constexpr bool traverse{true};
25118 static constexpr auto mbr_ptr{&SgPrintStatement::p_format};
25119 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25120 using bind = Desc<SgPrintStatement, SgExpression* SgPrintStatement::*, &SgPrintStatement::p_format>;
25121};
25123 using node = SgPrintStatement;
25124 using base = SgIOStatement;
25125 static constexpr char const * const name{"PrintStatement"};
25126 static constexpr unsigned long variant{654};
25127 static constexpr bool concrete{true};
25128 using subclasses_t = mp::List<>;
25130};
25131template <> struct node_from_variant_t<654> { using type = SgPrintStatement; };
25132
25133// Class: ProcedureHeaderStatement
25134template <> struct describe_field_t<SgProcedureHeaderStatement,SgProcedureHeaderStatement::subprogram_kind_enum,&SgProcedureHeaderStatement::p_subprogram_kind> {
25137 static constexpr size_t position{0};
25138 static constexpr char const * const name{"subprogram_kind"};
25139 static constexpr char const * const typestr{"SgProcedureHeaderStatement::subprogram_kind_enum"};
25140 static constexpr bool traverse{false};
25141 static constexpr auto mbr_ptr{&SgProcedureHeaderStatement::p_subprogram_kind};
25142 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25143 using bind = Desc<SgProcedureHeaderStatement, SgProcedureHeaderStatement::subprogram_kind_enum SgProcedureHeaderStatement::*, &SgProcedureHeaderStatement::p_subprogram_kind>;
25144};
25145template <> struct describe_field_t<SgProcedureHeaderStatement,SgLabelRefExp*,&SgProcedureHeaderStatement::p_end_numeric_label> {
25147 using field_type = SgLabelRefExp*;
25148 static constexpr size_t position{1};
25149 static constexpr char const * const name{"end_numeric_label"};
25150 static constexpr char const * const typestr{"SgLabelRefExp*"};
25151 static constexpr bool traverse{false};
25152 static constexpr auto mbr_ptr{&SgProcedureHeaderStatement::p_end_numeric_label};
25153 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25154 using bind = Desc<SgProcedureHeaderStatement, SgLabelRefExp* SgProcedureHeaderStatement::*, &SgProcedureHeaderStatement::p_end_numeric_label>;
25155};
25156template <> struct describe_field_t<SgProcedureHeaderStatement,SgInitializedName*,&SgProcedureHeaderStatement::p_result_name> {
25159 static constexpr size_t position{2};
25160 static constexpr char const * const name{"result_name"};
25161 static constexpr char const * const typestr{"SgInitializedName*"};
25162 static constexpr bool traverse{true};
25163 static constexpr auto mbr_ptr{&SgProcedureHeaderStatement::p_result_name};
25164 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25165 using bind = Desc<SgProcedureHeaderStatement, SgInitializedName* SgProcedureHeaderStatement::*, &SgProcedureHeaderStatement::p_result_name>;
25166};
25176template <> struct node_from_variant_t<655> { using type = SgProcedureHeaderStatement; };
25177
25178// Class: ProgramHeaderStatement
25179template <> struct describe_field_t<SgProgramHeaderStatement,bool,&SgProgramHeaderStatement::p_program_statement_explicit> {
25181 using field_type = bool;
25182 static constexpr size_t position{0};
25183 static constexpr char const * const name{"program_statement_explicit"};
25184 static constexpr char const * const typestr{"bool"};
25185 static constexpr bool traverse{false};
25186 static constexpr auto mbr_ptr{&SgProgramHeaderStatement::p_program_statement_explicit};
25187 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25188 using bind = Desc<SgProgramHeaderStatement, bool SgProgramHeaderStatement::*, &SgProgramHeaderStatement::p_program_statement_explicit>;
25189};
25190template <> struct describe_field_t<SgProgramHeaderStatement,SgLabelRefExp*,&SgProgramHeaderStatement::p_end_numeric_label> {
25192 using field_type = SgLabelRefExp*;
25193 static constexpr size_t position{1};
25194 static constexpr char const * const name{"end_numeric_label"};
25195 static constexpr char const * const typestr{"SgLabelRefExp*"};
25196 static constexpr bool traverse{false};
25197 static constexpr auto mbr_ptr{&SgProgramHeaderStatement::p_end_numeric_label};
25198 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25199 using bind = Desc<SgProgramHeaderStatement, SgLabelRefExp* SgProgramHeaderStatement::*, &SgProgramHeaderStatement::p_end_numeric_label>;
25200};
25204 static constexpr char const * const name{"ProgramHeaderStatement"};
25205 static constexpr unsigned long variant{656};
25206 static constexpr bool concrete{true};
25207 using subclasses_t = mp::List<>;
25209};
25210template <> struct node_from_variant_t<656> { using type = SgProgramHeaderStatement; };
25211
25212// Class: Project
25213template <> struct describe_field_t<SgProject,SgFileList*,&SgProject::p_fileList_ptr> {
25214 using parent = SgProject;
25215 using field_type = SgFileList*;
25216 static constexpr size_t position{0};
25217 static constexpr char const * const name{"fileList_ptr"};
25218 static constexpr char const * const typestr{"SgFileList*"};
25219 static constexpr bool traverse{true};
25220 static constexpr auto mbr_ptr{&SgProject::p_fileList_ptr};
25221 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25222 using bind = Desc<SgProject, SgFileList* SgProject::*, &SgProject::p_fileList_ptr>;
25223};
25225 using parent = SgProject;
25226 using field_type = SgStringList;
25227 static constexpr size_t position{1};
25228 static constexpr char const * const name{"originalCommandLineArgumentList"};
25229 static constexpr char const * const typestr{"SgStringList"};
25230 static constexpr bool traverse{false};
25231 static constexpr auto mbr_ptr{&SgProject::p_originalCommandLineArgumentList};
25232 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25233 using bind = Desc<SgProject, SgStringList SgProject::*, &SgProject::p_originalCommandLineArgumentList>;
25234};
25236 using parent = SgProject;
25237 using field_type = int;
25238 static constexpr size_t position{2};
25239 static constexpr char const * const name{"frontendErrorCode"};
25240 static constexpr char const * const typestr{"int"};
25241 static constexpr bool traverse{false};
25242 static constexpr auto mbr_ptr{&SgProject::p_frontendErrorCode};
25243 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25244 using bind = Desc<SgProject, int SgProject::*, &SgProject::p_frontendErrorCode>;
25245};
25246template <> struct describe_field_t<SgProject,int,&SgProject::p_javacErrorCode> {
25247 using parent = SgProject;
25248 using field_type = int;
25249 static constexpr size_t position{3};
25250 static constexpr char const * const name{"javacErrorCode"};
25251 static constexpr char const * const typestr{"int"};
25252 static constexpr bool traverse{false};
25253 static constexpr auto mbr_ptr{&SgProject::p_javacErrorCode};
25254 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25255 using bind = Desc<SgProject, int SgProject::*, &SgProject::p_javacErrorCode>;
25256};
25257template <> struct describe_field_t<SgProject,int,&SgProject::p_ecjErrorCode> {
25258 using parent = SgProject;
25259 using field_type = int;
25260 static constexpr size_t position{4};
25261 static constexpr char const * const name{"ecjErrorCode"};
25262 static constexpr char const * const typestr{"int"};
25263 static constexpr bool traverse{false};
25264 static constexpr auto mbr_ptr{&SgProject::p_ecjErrorCode};
25265 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25266 using bind = Desc<SgProject, int SgProject::*, &SgProject::p_ecjErrorCode>;
25267};
25268template <> struct describe_field_t<SgProject,int,&SgProject::p_midendErrorCode> {
25269 using parent = SgProject;
25270 using field_type = int;
25271 static constexpr size_t position{5};
25272 static constexpr char const * const name{"midendErrorCode"};
25273 static constexpr char const * const typestr{"int"};
25274 static constexpr bool traverse{false};
25275 static constexpr auto mbr_ptr{&SgProject::p_midendErrorCode};
25276 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25277 using bind = Desc<SgProject, int SgProject::*, &SgProject::p_midendErrorCode>;
25278};
25280 using parent = SgProject;
25281 using field_type = int;
25282 static constexpr size_t position{6};
25283 static constexpr char const * const name{"backendErrorCode"};
25284 static constexpr char const * const typestr{"int"};
25285 static constexpr bool traverse{false};
25286 static constexpr auto mbr_ptr{&SgProject::p_backendErrorCode};
25287 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25288 using bind = Desc<SgProject, int SgProject::*, &SgProject::p_backendErrorCode>;
25289};
25290template <> struct describe_field_t<SgProject,bool,&SgProject::p_keep_going> {
25291 using parent = SgProject;
25292 using field_type = bool;
25293 static constexpr size_t position{7};
25294 static constexpr char const * const name{"keep_going"};
25295 static constexpr char const * const typestr{"bool"};
25296 static constexpr bool traverse{false};
25297 static constexpr auto mbr_ptr{&SgProject::p_keep_going};
25298 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25299 using bind = Desc<SgProject, bool SgProject::*, &SgProject::p_keep_going>;
25300};
25301template <> struct describe_field_t<SgProject,bool,&SgProject::p_unparser__clobber_input_file> {
25302 using parent = SgProject;
25303 using field_type = bool;
25304 static constexpr size_t position{8};
25305 static constexpr char const * const name{"unparser__clobber_input_file"};
25306 static constexpr char const * const typestr{"bool"};
25307 static constexpr bool traverse{false};
25308 static constexpr auto mbr_ptr{&SgProject::p_unparser__clobber_input_file};
25309 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25310 using bind = Desc<SgProject, bool SgProject::*, &SgProject::p_unparser__clobber_input_file>;
25311};
25313 using parent = SgProject;
25314 using field_type = std::string;
25315 static constexpr size_t position{9};
25316 static constexpr char const * const name{"outputFileName"};
25317 static constexpr char const * const typestr{"std::string"};
25318 static constexpr bool traverse{false};
25319 static constexpr auto mbr_ptr{&SgProject::p_outputFileName};
25320 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25321 using bind = Desc<SgProject, std::string SgProject::*, &SgProject::p_outputFileName>;
25322};
25324 using parent = SgProject;
25325 using field_type = SgStringList;
25326 static constexpr size_t position{10};
25327 static constexpr char const * const name{"sourceFileNameList"};
25328 static constexpr char const * const typestr{"SgStringList"};
25329 static constexpr bool traverse{false};
25330 static constexpr auto mbr_ptr{&SgProject::p_sourceFileNameList};
25331 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25332 using bind = Desc<SgProject, SgStringList SgProject::*, &SgProject::p_sourceFileNameList>;
25333};
25335 using parent = SgProject;
25336 using field_type = SgStringList;
25337 static constexpr size_t position{11};
25338 static constexpr char const * const name{"objectFileNameList"};
25339 static constexpr char const * const typestr{"SgStringList"};
25340 static constexpr bool traverse{false};
25341 static constexpr auto mbr_ptr{&SgProject::p_objectFileNameList};
25342 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25343 using bind = Desc<SgProject, SgStringList SgProject::*, &SgProject::p_objectFileNameList>;
25344};
25346 using parent = SgProject;
25347 using field_type = SgStringList;
25348 static constexpr size_t position{12};
25349 static constexpr char const * const name{"libraryFileList"};
25350 static constexpr char const * const typestr{"SgStringList"};
25351 static constexpr bool traverse{false};
25352 static constexpr auto mbr_ptr{&SgProject::p_libraryFileList};
25353 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25354 using bind = Desc<SgProject, SgStringList SgProject::*, &SgProject::p_libraryFileList>;
25355};
25357 using parent = SgProject;
25358 using field_type = SgStringList;
25359 static constexpr size_t position{13};
25360 static constexpr char const * const name{"librarySpecifierList"};
25361 static constexpr char const * const typestr{"SgStringList"};
25362 static constexpr bool traverse{false};
25363 static constexpr auto mbr_ptr{&SgProject::p_librarySpecifierList};
25364 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25365 using bind = Desc<SgProject, SgStringList SgProject::*, &SgProject::p_librarySpecifierList>;
25366};
25368 using parent = SgProject;
25369 using field_type = SgStringList;
25370 static constexpr size_t position{14};
25371 static constexpr char const * const name{"libraryDirectorySpecifierList"};
25372 static constexpr char const * const typestr{"SgStringList"};
25373 static constexpr bool traverse{false};
25374 static constexpr auto mbr_ptr{&SgProject::p_libraryDirectorySpecifierList};
25375 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25376 using bind = Desc<SgProject, SgStringList SgProject::*, &SgProject::p_libraryDirectorySpecifierList>;
25377};
25379 using parent = SgProject;
25380 using field_type = SgStringList;
25381 static constexpr size_t position{15};
25382 static constexpr char const * const name{"includeDirectorySpecifierList"};
25383 static constexpr char const * const typestr{"SgStringList"};
25384 static constexpr bool traverse{false};
25385 static constexpr auto mbr_ptr{&SgProject::p_includeDirectorySpecifierList};
25386 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25387 using bind = Desc<SgProject, SgStringList SgProject::*, &SgProject::p_includeDirectorySpecifierList>;
25388};
25389template <> struct describe_field_t<SgProject,SgStringList,&SgProject::p_macroSpecifierList> {
25390 using parent = SgProject;
25391 using field_type = SgStringList;
25392 static constexpr size_t position{16};
25393 static constexpr char const * const name{"macroSpecifierList"};
25394 static constexpr char const * const typestr{"SgStringList"};
25395 static constexpr bool traverse{false};
25396 static constexpr auto mbr_ptr{&SgProject::p_macroSpecifierList};
25397 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25398 using bind = Desc<SgProject, SgStringList SgProject::*, &SgProject::p_macroSpecifierList>;
25399};
25400template <> struct describe_field_t<SgProject,SgStringList,&SgProject::p_preincludeFileList> {
25401 using parent = SgProject;
25402 using field_type = SgStringList;
25403 static constexpr size_t position{17};
25404 static constexpr char const * const name{"preincludeFileList"};
25405 static constexpr char const * const typestr{"SgStringList"};
25406 static constexpr bool traverse{false};
25407 static constexpr auto mbr_ptr{&SgProject::p_preincludeFileList};
25408 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25409 using bind = Desc<SgProject, SgStringList SgProject::*, &SgProject::p_preincludeFileList>;
25410};
25411template <> struct describe_field_t<SgProject,SgStringList,&SgProject::p_preincludeDirectoryList> {
25412 using parent = SgProject;
25413 using field_type = SgStringList;
25414 static constexpr size_t position{18};
25415 static constexpr char const * const name{"preincludeDirectoryList"};
25416 static constexpr char const * const typestr{"SgStringList"};
25417 static constexpr bool traverse{false};
25418 static constexpr auto mbr_ptr{&SgProject::p_preincludeDirectoryList};
25419 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25420 using bind = Desc<SgProject, SgStringList SgProject::*, &SgProject::p_preincludeDirectoryList>;
25421};
25423 using parent = SgProject;
25424 using field_type = bool;
25425 static constexpr size_t position{19};
25426 static constexpr char const * const name{"compileOnly"};
25427 static constexpr char const * const typestr{"bool"};
25428 static constexpr bool traverse{false};
25429 static constexpr auto mbr_ptr{&SgProject::p_compileOnly};
25430 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25431 using bind = Desc<SgProject, bool SgProject::*, &SgProject::p_compileOnly>;
25432};
25433template <> struct describe_field_t<SgProject,bool,&SgProject::p_wave> {
25434 using parent = SgProject;
25435 using field_type = bool;
25436 static constexpr size_t position{20};
25437 static constexpr char const * const name{"wave"};
25438 static constexpr char const * const typestr{"bool"};
25439 static constexpr bool traverse{false};
25440 static constexpr auto mbr_ptr{&SgProject::p_wave};
25441 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25442 using bind = Desc<SgProject, bool SgProject::*, &SgProject::p_wave>;
25443};
25445 using parent = SgProject;
25446 using field_type = bool;
25447 static constexpr size_t position{21};
25448 static constexpr char const * const name{"prelink"};
25449 static constexpr char const * const typestr{"bool"};
25450 static constexpr bool traverse{false};
25451 static constexpr auto mbr_ptr{&SgProject::p_prelink};
25452 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25453 using bind = Desc<SgProject, bool SgProject::*, &SgProject::p_prelink>;
25454};
25455template <> struct describe_field_t<SgProject,SgProject::template_instantiation_enum,&SgProject::p_template_instantiation_mode> {
25456 using parent = SgProject;
25458 static constexpr size_t position{22};
25459 static constexpr char const * const name{"template_instantiation_mode"};
25460 static constexpr char const * const typestr{"SgProject::template_instantiation_enum"};
25461 static constexpr bool traverse{false};
25462 static constexpr auto mbr_ptr{&SgProject::p_template_instantiation_mode};
25463 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25464 using bind = Desc<SgProject, SgProject::template_instantiation_enum SgProject::*, &SgProject::p_template_instantiation_mode>;
25465};
25466template <> struct describe_field_t<SgProject,bool,&SgProject::p_ast_merge> {
25467 using parent = SgProject;
25468 using field_type = bool;
25469 static constexpr size_t position{23};
25470 static constexpr char const * const name{"ast_merge"};
25471 static constexpr char const * const typestr{"bool"};
25472 static constexpr bool traverse{false};
25473 static constexpr auto mbr_ptr{&SgProject::p_ast_merge};
25474 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25475 using bind = Desc<SgProject, bool SgProject::*, &SgProject::p_ast_merge>;
25476};
25477template <> struct describe_field_t<SgProject,std::string,&SgProject::p_projectSpecificDatabaseFile> {
25478 using parent = SgProject;
25479 using field_type = std::string;
25480 static constexpr size_t position{24};
25481 static constexpr char const * const name{"projectSpecificDatabaseFile"};
25482 static constexpr char const * const typestr{"std::string"};
25483 static constexpr bool traverse{false};
25484 static constexpr auto mbr_ptr{&SgProject::p_projectSpecificDatabaseFile};
25485 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25486 using bind = Desc<SgProject, std::string SgProject::*, &SgProject::p_projectSpecificDatabaseFile>;
25487};
25488template <> struct describe_field_t<SgProject,bool,&SgProject::p_C_PreprocessorOnly> {
25489 using parent = SgProject;
25490 using field_type = bool;
25491 static constexpr size_t position{25};
25492 static constexpr char const * const name{"C_PreprocessorOnly"};
25493 static constexpr char const * const typestr{"bool"};
25494 static constexpr bool traverse{false};
25495 static constexpr auto mbr_ptr{&SgProject::p_C_PreprocessorOnly};
25496 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25497 using bind = Desc<SgProject, bool SgProject::*, &SgProject::p_C_PreprocessorOnly>;
25498};
25499template <> struct describe_field_t<SgProject,AstAttributeMechanism*,&SgProject::p_attributeMechanism> {
25500 using parent = SgProject;
25502 static constexpr size_t position{26};
25503 static constexpr char const * const name{"attributeMechanism"};
25504 static constexpr char const * const typestr{"AstAttributeMechanism*"};
25505 static constexpr bool traverse{false};
25506 static constexpr auto mbr_ptr{&SgProject::p_attributeMechanism};
25507 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25508 using bind = Desc<SgProject, AstAttributeMechanism* SgProject::*, &SgProject::p_attributeMechanism>;
25509};
25510template <> struct describe_field_t<SgProject,std::string,&SgProject::p_compilationPerformanceFile> {
25511 using parent = SgProject;
25512 using field_type = std::string;
25513 static constexpr size_t position{27};
25514 static constexpr char const * const name{"compilationPerformanceFile"};
25515 static constexpr char const * const typestr{"std::string"};
25516 static constexpr bool traverse{false};
25517 static constexpr auto mbr_ptr{&SgProject::p_compilationPerformanceFile};
25518 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25519 using bind = Desc<SgProject, std::string SgProject::*, &SgProject::p_compilationPerformanceFile>;
25520};
25521template <> struct describe_field_t<SgProject,SgStringList,&SgProject::p_includePathList> {
25522 using parent = SgProject;
25523 using field_type = SgStringList;
25524 static constexpr size_t position{28};
25525 static constexpr char const * const name{"includePathList"};
25526 static constexpr char const * const typestr{"SgStringList"};
25527 static constexpr bool traverse{false};
25528 static constexpr auto mbr_ptr{&SgProject::p_includePathList};
25529 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25530 using bind = Desc<SgProject, SgStringList SgProject::*, &SgProject::p_includePathList>;
25531};
25532template <> struct describe_field_t<SgProject,SgStringList,&SgProject::p_excludePathList> {
25533 using parent = SgProject;
25534 using field_type = SgStringList;
25535 static constexpr size_t position{29};
25536 static constexpr char const * const name{"excludePathList"};
25537 static constexpr char const * const typestr{"SgStringList"};
25538 static constexpr bool traverse{false};
25539 static constexpr auto mbr_ptr{&SgProject::p_excludePathList};
25540 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25541 using bind = Desc<SgProject, SgStringList SgProject::*, &SgProject::p_excludePathList>;
25542};
25543template <> struct describe_field_t<SgProject,SgStringList,&SgProject::p_includeFileList> {
25544 using parent = SgProject;
25545 using field_type = SgStringList;
25546 static constexpr size_t position{30};
25547 static constexpr char const * const name{"includeFileList"};
25548 static constexpr char const * const typestr{"SgStringList"};
25549 static constexpr bool traverse{false};
25550 static constexpr auto mbr_ptr{&SgProject::p_includeFileList};
25551 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25552 using bind = Desc<SgProject, SgStringList SgProject::*, &SgProject::p_includeFileList>;
25553};
25554template <> struct describe_field_t<SgProject,SgStringList,&SgProject::p_excludeFileList> {
25555 using parent = SgProject;
25556 using field_type = SgStringList;
25557 static constexpr size_t position{31};
25558 static constexpr char const * const name{"excludeFileList"};
25559 static constexpr char const * const typestr{"SgStringList"};
25560 static constexpr bool traverse{false};
25561 static constexpr auto mbr_ptr{&SgProject::p_excludeFileList};
25562 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25563 using bind = Desc<SgProject, SgStringList SgProject::*, &SgProject::p_excludeFileList>;
25564};
25565template <> struct describe_field_t<SgProject,bool,&SgProject::p_binary_only> {
25566 using parent = SgProject;
25567 using field_type = bool;
25568 static constexpr size_t position{32};
25569 static constexpr char const * const name{"binary_only"};
25570 static constexpr char const * const typestr{"bool"};
25571 static constexpr bool traverse{false};
25572 static constexpr auto mbr_ptr{&SgProject::p_binary_only};
25573 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25574 using bind = Desc<SgProject, bool SgProject::*, &SgProject::p_binary_only>;
25575};
25576template <> struct describe_field_t<SgProject,std::string,&SgProject::p_dataBaseFilename> {
25577 using parent = SgProject;
25578 using field_type = std::string;
25579 static constexpr size_t position{33};
25580 static constexpr char const * const name{"dataBaseFilename"};
25581 static constexpr char const * const typestr{"std::string"};
25582 static constexpr bool traverse{false};
25583 static constexpr auto mbr_ptr{&SgProject::p_dataBaseFilename};
25584 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25585 using bind = Desc<SgProject, std::string SgProject::*, &SgProject::p_dataBaseFilename>;
25586};
25587template <> struct describe_field_t<SgProject,SgDirectoryList*,&SgProject::p_directoryList> {
25588 using parent = SgProject;
25589 using field_type = SgDirectoryList*;
25590 static constexpr size_t position{34};
25591 static constexpr char const * const name{"directoryList"};
25592 static constexpr char const * const typestr{"SgDirectoryList*"};
25593 static constexpr bool traverse{false};
25594 static constexpr auto mbr_ptr{&SgProject::p_directoryList};
25595 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25596 using bind = Desc<SgProject, SgDirectoryList* SgProject::*, &SgProject::p_directoryList>;
25597};
25598template <> struct describe_field_t<SgProject,bool,&SgProject::p_C_only> {
25599 using parent = SgProject;
25600 using field_type = bool;
25601 static constexpr size_t position{35};
25602 static constexpr char const * const name{"C_only"};
25603 static constexpr char const * const typestr{"bool"};
25604 static constexpr bool traverse{false};
25605 static constexpr auto mbr_ptr{&SgProject::p_C_only};
25606 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25607 using bind = Desc<SgProject, bool SgProject::*, &SgProject::p_C_only>;
25608};
25609template <> struct describe_field_t<SgProject,bool,&SgProject::p_Cxx_only> {
25610 using parent = SgProject;
25611 using field_type = bool;
25612 static constexpr size_t position{36};
25613 static constexpr char const * const name{"Cxx_only"};
25614 static constexpr char const * const typestr{"bool"};
25615 static constexpr bool traverse{false};
25616 static constexpr auto mbr_ptr{&SgProject::p_Cxx_only};
25617 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25618 using bind = Desc<SgProject, bool SgProject::*, &SgProject::p_Cxx_only>;
25619};
25620template <> struct describe_field_t<SgProject,bool,&SgProject::p_C11_only> {
25621 using parent = SgProject;
25622 using field_type = bool;
25623 static constexpr size_t position{37};
25624 static constexpr char const * const name{"C11_only"};
25625 static constexpr char const * const typestr{"bool"};
25626 static constexpr bool traverse{false};
25627 static constexpr auto mbr_ptr{&SgProject::p_C11_only};
25628 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25629 using bind = Desc<SgProject, bool SgProject::*, &SgProject::p_C11_only>;
25630};
25631template <> struct describe_field_t<SgProject,bool,&SgProject::p_Cxx0x_only> {
25632 using parent = SgProject;
25633 using field_type = bool;
25634 static constexpr size_t position{38};
25635 static constexpr char const * const name{"Cxx0x_only"};
25636 static constexpr char const * const typestr{"bool"};
25637 static constexpr bool traverse{false};
25638 static constexpr auto mbr_ptr{&SgProject::p_Cxx0x_only};
25639 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25640 using bind = Desc<SgProject, bool SgProject::*, &SgProject::p_Cxx0x_only>;
25641};
25642template <> struct describe_field_t<SgProject,bool,&SgProject::p_Cxx11_only> {
25643 using parent = SgProject;
25644 using field_type = bool;
25645 static constexpr size_t position{39};
25646 static constexpr char const * const name{"Cxx11_only"};
25647 static constexpr char const * const typestr{"bool"};
25648 static constexpr bool traverse{false};
25649 static constexpr auto mbr_ptr{&SgProject::p_Cxx11_only};
25650 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25651 using bind = Desc<SgProject, bool SgProject::*, &SgProject::p_Cxx11_only>;
25652};
25653template <> struct describe_field_t<SgProject,bool,&SgProject::p_C14_only> {
25654 using parent = SgProject;
25655 using field_type = bool;
25656 static constexpr size_t position{40};
25657 static constexpr char const * const name{"C14_only"};
25658 static constexpr char const * const typestr{"bool"};
25659 static constexpr bool traverse{false};
25660 static constexpr auto mbr_ptr{&SgProject::p_C14_only};
25661 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25662 using bind = Desc<SgProject, bool SgProject::*, &SgProject::p_C14_only>;
25663};
25664template <> struct describe_field_t<SgProject,bool,&SgProject::p_Cxx14_only> {
25665 using parent = SgProject;
25666 using field_type = bool;
25667 static constexpr size_t position{41};
25668 static constexpr char const * const name{"Cxx14_only"};
25669 static constexpr char const * const typestr{"bool"};
25670 static constexpr bool traverse{false};
25671 static constexpr auto mbr_ptr{&SgProject::p_Cxx14_only};
25672 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25673 using bind = Desc<SgProject, bool SgProject::*, &SgProject::p_Cxx14_only>;
25674};
25675template <> struct describe_field_t<SgProject,bool,&SgProject::p_Fortran_only> {
25676 using parent = SgProject;
25677 using field_type = bool;
25678 static constexpr size_t position{42};
25679 static constexpr char const * const name{"Fortran_only"};
25680 static constexpr char const * const typestr{"bool"};
25681 static constexpr bool traverse{false};
25682 static constexpr auto mbr_ptr{&SgProject::p_Fortran_only};
25683 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25684 using bind = Desc<SgProject, bool SgProject::*, &SgProject::p_Fortran_only>;
25685};
25686template <> struct describe_field_t<SgProject,std::list<std::string>,&SgProject::p_Fortran_ofp_jvm_options> {
25687 using parent = SgProject;
25688 using field_type = std::list<std::string>;
25689 static constexpr size_t position{43};
25690 static constexpr char const * const name{"Fortran_ofp_jvm_options"};
25691 static constexpr char const * const typestr{"std::list<std::string>"};
25692 static constexpr bool traverse{false};
25693 static constexpr auto mbr_ptr{&SgProject::p_Fortran_ofp_jvm_options};
25694 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25695 using bind = Desc<SgProject, std::list<std::string> SgProject::*, &SgProject::p_Fortran_ofp_jvm_options>;
25696};
25697template <> struct describe_field_t<SgProject,bool,&SgProject::p_Java_only> {
25698 using parent = SgProject;
25699 using field_type = bool;
25700 static constexpr size_t position{44};
25701 static constexpr char const * const name{"Java_only"};
25702 static constexpr char const * const typestr{"bool"};
25703 static constexpr bool traverse{false};
25704 static constexpr auto mbr_ptr{&SgProject::p_Java_only};
25705 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25706 using bind = Desc<SgProject, bool SgProject::*, &SgProject::p_Java_only>;
25707};
25708template <> struct describe_field_t<SgProject,bool,&SgProject::p_Jvm_only> {
25709 using parent = SgProject;
25710 using field_type = bool;
25711 static constexpr size_t position{45};
25712 static constexpr char const * const name{"Jvm_only"};
25713 static constexpr char const * const typestr{"bool"};
25714 static constexpr bool traverse{false};
25715 static constexpr auto mbr_ptr{&SgProject::p_Jvm_only};
25716 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25717 using bind = Desc<SgProject, bool SgProject::*, &SgProject::p_Jvm_only>;
25718};
25719template <> struct describe_field_t<SgProject,bool,&SgProject::p_Jovial_only> {
25720 using parent = SgProject;
25721 using field_type = bool;
25722 static constexpr size_t position{46};
25723 static constexpr char const * const name{"Jovial_only"};
25724 static constexpr char const * const typestr{"bool"};
25725 static constexpr bool traverse{false};
25726 static constexpr auto mbr_ptr{&SgProject::p_Jovial_only};
25727 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25728 using bind = Desc<SgProject, bool SgProject::*, &SgProject::p_Jovial_only>;
25729};
25730template <> struct describe_field_t<SgProject,bool,&SgProject::p_Ada_only> {
25731 using parent = SgProject;
25732 using field_type = bool;
25733 static constexpr size_t position{47};
25734 static constexpr char const * const name{"Ada_only"};
25735 static constexpr char const * const typestr{"bool"};
25736 static constexpr bool traverse{false};
25737 static constexpr auto mbr_ptr{&SgProject::p_Ada_only};
25738 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25739 using bind = Desc<SgProject, bool SgProject::*, &SgProject::p_Ada_only>;
25740};
25742 using parent = SgProject;
25743 using field_type = bool;
25744 static constexpr size_t position{48};
25745 static constexpr char const * const name{"openmp_linking"};
25746 static constexpr char const * const typestr{"bool"};
25747 static constexpr bool traverse{false};
25748 static constexpr auto mbr_ptr{&SgProject::p_openmp_linking};
25749 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25750 using bind = Desc<SgProject, bool SgProject::*, &SgProject::p_openmp_linking>;
25751};
25752template <> struct describe_field_t<SgProject,std::list<std::string>,&SgProject::p_Java_ecj_jvm_options> {
25753 using parent = SgProject;
25754 using field_type = std::list<std::string>;
25755 static constexpr size_t position{49};
25756 static constexpr char const * const name{"Java_ecj_jvm_options"};
25757 static constexpr char const * const typestr{"std::list<std::string>"};
25758 static constexpr bool traverse{false};
25759 static constexpr auto mbr_ptr{&SgProject::p_Java_ecj_jvm_options};
25760 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25761 using bind = Desc<SgProject, std::list<std::string> SgProject::*, &SgProject::p_Java_ecj_jvm_options>;
25762};
25763template <> struct describe_field_t<SgProject,bool,&SgProject::p_Java_batch_mode> {
25764 using parent = SgProject;
25765 using field_type = bool;
25766 static constexpr size_t position{50};
25767 static constexpr char const * const name{"Java_batch_mode"};
25768 static constexpr char const * const typestr{"bool"};
25769 static constexpr bool traverse{false};
25770 static constexpr auto mbr_ptr{&SgProject::p_Java_batch_mode};
25771 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25772 using bind = Desc<SgProject, bool SgProject::*, &SgProject::p_Java_batch_mode>;
25773};
25774template <> struct describe_field_t<SgProject,std::list<std::string>,&SgProject::p_Java_classpath> {
25775 using parent = SgProject;
25776 using field_type = std::list<std::string>;
25777 static constexpr size_t position{51};
25778 static constexpr char const * const name{"Java_classpath"};
25779 static constexpr char const * const typestr{"std::list<std::string>"};
25780 static constexpr bool traverse{false};
25781 static constexpr auto mbr_ptr{&SgProject::p_Java_classpath};
25782 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25783 using bind = Desc<SgProject, std::list<std::string> SgProject::*, &SgProject::p_Java_classpath>;
25784};
25785template <> struct describe_field_t<SgProject,std::list<std::string>,&SgProject::p_Java_sourcepath> {
25786 using parent = SgProject;
25787 using field_type = std::list<std::string>;
25788 static constexpr size_t position{52};
25789 static constexpr char const * const name{"Java_sourcepath"};
25790 static constexpr char const * const typestr{"std::list<std::string>"};
25791 static constexpr bool traverse{false};
25792 static constexpr auto mbr_ptr{&SgProject::p_Java_sourcepath};
25793 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25794 using bind = Desc<SgProject, std::list<std::string> SgProject::*, &SgProject::p_Java_sourcepath>;
25795};
25796template <> struct describe_field_t<SgProject,std::string,&SgProject::p_Java_destdir> {
25797 using parent = SgProject;
25798 using field_type = std::string;
25799 static constexpr size_t position{53};
25800 static constexpr char const * const name{"Java_destdir"};
25801 static constexpr char const * const typestr{"std::string"};
25802 static constexpr bool traverse{false};
25803 static constexpr auto mbr_ptr{&SgProject::p_Java_destdir};
25804 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25805 using bind = Desc<SgProject, std::string SgProject::*, &SgProject::p_Java_destdir>;
25806};
25807template <> struct describe_field_t<SgProject,std::string,&SgProject::p_Java_source_destdir> {
25808 using parent = SgProject;
25809 using field_type = std::string;
25810 static constexpr size_t position{54};
25811 static constexpr char const * const name{"Java_source_destdir"};
25812 static constexpr char const * const typestr{"std::string"};
25813 static constexpr bool traverse{false};
25814 static constexpr auto mbr_ptr{&SgProject::p_Java_source_destdir};
25815 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25816 using bind = Desc<SgProject, std::string SgProject::*, &SgProject::p_Java_source_destdir>;
25817};
25818template <> struct describe_field_t<SgProject,std::string,&SgProject::p_Java_s> {
25819 using parent = SgProject;
25820 using field_type = std::string;
25821 static constexpr size_t position{55};
25822 static constexpr char const * const name{"Java_s"};
25823 static constexpr char const * const typestr{"std::string"};
25824 static constexpr bool traverse{false};
25825 static constexpr auto mbr_ptr{&SgProject::p_Java_s};
25826 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25827 using bind = Desc<SgProject, std::string SgProject::*, &SgProject::p_Java_s>;
25828};
25829template <> struct describe_field_t<SgProject,std::string,&SgProject::p_Java_source> {
25830 using parent = SgProject;
25831 using field_type = std::string;
25832 static constexpr size_t position{56};
25833 static constexpr char const * const name{"Java_source"};
25834 static constexpr char const * const typestr{"std::string"};
25835 static constexpr bool traverse{false};
25836 static constexpr auto mbr_ptr{&SgProject::p_Java_source};
25837 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25838 using bind = Desc<SgProject, std::string SgProject::*, &SgProject::p_Java_source>;
25839};
25840template <> struct describe_field_t<SgProject,std::string,&SgProject::p_Java_target> {
25841 using parent = SgProject;
25842 using field_type = std::string;
25843 static constexpr size_t position{57};
25844 static constexpr char const * const name{"Java_target"};
25845 static constexpr char const * const typestr{"std::string"};
25846 static constexpr bool traverse{false};
25847 static constexpr auto mbr_ptr{&SgProject::p_Java_target};
25848 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25849 using bind = Desc<SgProject, std::string SgProject::*, &SgProject::p_Java_target>;
25850};
25851template <> struct describe_field_t<SgProject,std::string,&SgProject::p_Java_encoding> {
25852 using parent = SgProject;
25853 using field_type = std::string;
25854 static constexpr size_t position{58};
25855 static constexpr char const * const name{"Java_encoding"};
25856 static constexpr char const * const typestr{"std::string"};
25857 static constexpr bool traverse{false};
25858 static constexpr auto mbr_ptr{&SgProject::p_Java_encoding};
25859 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25860 using bind = Desc<SgProject, std::string SgProject::*, &SgProject::p_Java_encoding>;
25861};
25862template <> struct describe_field_t<SgProject,std::string,&SgProject::p_Java_g> {
25863 using parent = SgProject;
25864 using field_type = std::string;
25865 static constexpr size_t position{59};
25866 static constexpr char const * const name{"Java_g"};
25867 static constexpr char const * const typestr{"std::string"};
25868 static constexpr bool traverse{false};
25869 static constexpr auto mbr_ptr{&SgProject::p_Java_g};
25870 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25871 using bind = Desc<SgProject, std::string SgProject::*, &SgProject::p_Java_g>;
25872};
25873template <> struct describe_field_t<SgProject,bool,&SgProject::p_Java_nowarn> {
25874 using parent = SgProject;
25875 using field_type = bool;
25876 static constexpr size_t position{60};
25877 static constexpr char const * const name{"Java_nowarn"};
25878 static constexpr char const * const typestr{"bool"};
25879 static constexpr bool traverse{false};
25880 static constexpr auto mbr_ptr{&SgProject::p_Java_nowarn};
25881 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25882 using bind = Desc<SgProject, bool SgProject::*, &SgProject::p_Java_nowarn>;
25883};
25884template <> struct describe_field_t<SgProject,bool,&SgProject::p_Java_verbose> {
25885 using parent = SgProject;
25886 using field_type = bool;
25887 static constexpr size_t position{61};
25888 static constexpr char const * const name{"Java_verbose"};
25889 static constexpr char const * const typestr{"bool"};
25890 static constexpr bool traverse{false};
25891 static constexpr auto mbr_ptr{&SgProject::p_Java_verbose};
25892 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25893 using bind = Desc<SgProject, bool SgProject::*, &SgProject::p_Java_verbose>;
25894};
25895template <> struct describe_field_t<SgProject,bool,&SgProject::p_Java_deprecation> {
25896 using parent = SgProject;
25897 using field_type = bool;
25898 static constexpr size_t position{62};
25899 static constexpr char const * const name{"Java_deprecation"};
25900 static constexpr char const * const typestr{"bool"};
25901 static constexpr bool traverse{false};
25902 static constexpr auto mbr_ptr{&SgProject::p_Java_deprecation};
25903 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25904 using bind = Desc<SgProject, bool SgProject::*, &SgProject::p_Java_deprecation>;
25905};
25906template <> struct describe_field_t<SgProject,std::list<std::string>,&SgProject::p_Java_bootclasspath> {
25907 using parent = SgProject;
25908 using field_type = std::list<std::string>;
25909 static constexpr size_t position{63};
25910 static constexpr char const * const name{"Java_bootclasspath"};
25911 static constexpr char const * const typestr{"std::list<std::string>"};
25912 static constexpr bool traverse{false};
25913 static constexpr auto mbr_ptr{&SgProject::p_Java_bootclasspath};
25914 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25915 using bind = Desc<SgProject, std::list<std::string> SgProject::*, &SgProject::p_Java_bootclasspath>;
25916};
25917template <> struct describe_field_t<SgProject,bool,&SgProject::p_addCppDirectivesToAST> {
25918 using parent = SgProject;
25919 using field_type = bool;
25920 static constexpr size_t position{64};
25921 static constexpr char const * const name{"addCppDirectivesToAST"};
25922 static constexpr char const * const typestr{"bool"};
25923 static constexpr bool traverse{false};
25924 static constexpr auto mbr_ptr{&SgProject::p_addCppDirectivesToAST};
25925 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25926 using bind = Desc<SgProject, bool SgProject::*, &SgProject::p_addCppDirectivesToAST>;
25927};
25928template <> struct describe_field_t<SgProject,std::map<std::string, std::set<PreprocessingInfo*> >,&SgProject::p_includingPreprocessingInfosMap> {
25929 using parent = SgProject;
25930 using field_type = std::map<std::string, std::set<PreprocessingInfo*> >;
25931 static constexpr size_t position{65};
25932 static constexpr char const * const name{"includingPreprocessingInfosMap"};
25933 static constexpr char const * const typestr{"std::map<std::string, std::set<PreprocessingInfo*> >"};
25934 static constexpr bool traverse{false};
25935 static constexpr auto mbr_ptr{&SgProject::p_includingPreprocessingInfosMap};
25936 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25937 using bind = Desc<SgProject, std::map<std::string, std::set<PreprocessingInfo*> > SgProject::*, &SgProject::p_includingPreprocessingInfosMap>;
25938};
25939template <> struct describe_field_t<SgProject,std::list<std::string>,&SgProject::p_quotedIncludesSearchPaths> {
25940 using parent = SgProject;
25941 using field_type = std::list<std::string>;
25942 static constexpr size_t position{66};
25943 static constexpr char const * const name{"quotedIncludesSearchPaths"};
25944 static constexpr char const * const typestr{"std::list<std::string>"};
25945 static constexpr bool traverse{false};
25946 static constexpr auto mbr_ptr{&SgProject::p_quotedIncludesSearchPaths};
25947 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25948 using bind = Desc<SgProject, std::list<std::string> SgProject::*, &SgProject::p_quotedIncludesSearchPaths>;
25949};
25950template <> struct describe_field_t<SgProject,std::list<std::string>,&SgProject::p_bracketedIncludesSearchPaths> {
25951 using parent = SgProject;
25952 using field_type = std::list<std::string>;
25953 static constexpr size_t position{67};
25954 static constexpr char const * const name{"bracketedIncludesSearchPaths"};
25955 static constexpr char const * const typestr{"std::list<std::string>"};
25956 static constexpr bool traverse{false};
25957 static constexpr auto mbr_ptr{&SgProject::p_bracketedIncludesSearchPaths};
25958 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25959 using bind = Desc<SgProject, std::list<std::string> SgProject::*, &SgProject::p_bracketedIncludesSearchPaths>;
25960};
25961template <> struct describe_field_t<SgProject,std::string,&SgProject::p_unparseHeaderFilesRootFolder> {
25962 using parent = SgProject;
25963 using field_type = std::string;
25964 static constexpr size_t position{68};
25965 static constexpr char const * const name{"unparseHeaderFilesRootFolder"};
25966 static constexpr char const * const typestr{"std::string"};
25967 static constexpr bool traverse{false};
25968 static constexpr auto mbr_ptr{&SgProject::p_unparseHeaderFilesRootFolder};
25969 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25970 using bind = Desc<SgProject, std::string SgProject::*, &SgProject::p_unparseHeaderFilesRootFolder>;
25971};
25972template <> struct describe_field_t<SgProject,bool,&SgProject::p_frontendConstantFolding> {
25973 using parent = SgProject;
25974 using field_type = bool;
25975 static constexpr size_t position{69};
25976 static constexpr char const * const name{"frontendConstantFolding"};
25977 static constexpr char const * const typestr{"bool"};
25978 static constexpr bool traverse{false};
25979 static constexpr auto mbr_ptr{&SgProject::p_frontendConstantFolding};
25980 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25981 using bind = Desc<SgProject, bool SgProject::*, &SgProject::p_frontendConstantFolding>;
25982};
25983template <> struct describe_field_t<SgProject,SgGlobal*,&SgProject::p_globalScopeAcrossFiles> {
25984 using parent = SgProject;
25985 using field_type = SgGlobal*;
25986 static constexpr size_t position{70};
25987 static constexpr char const * const name{"globalScopeAcrossFiles"};
25988 static constexpr char const * const typestr{"SgGlobal*"};
25989 static constexpr bool traverse{false};
25990 static constexpr auto mbr_ptr{&SgProject::p_globalScopeAcrossFiles};
25991 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
25992 using bind = Desc<SgProject, SgGlobal* SgProject::*, &SgProject::p_globalScopeAcrossFiles>;
25993};
25994template <> struct describe_field_t<SgProject,bool,&SgProject::p_unparse_in_same_directory_as_input_file> {
25995 using parent = SgProject;
25996 using field_type = bool;
25997 static constexpr size_t position{71};
25998 static constexpr char const * const name{"unparse_in_same_directory_as_input_file"};
25999 static constexpr char const * const typestr{"bool"};
26000 static constexpr bool traverse{false};
26001 static constexpr auto mbr_ptr{&SgProject::p_unparse_in_same_directory_as_input_file};
26002 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26003 using bind = Desc<SgProject, bool SgProject::*, &SgProject::p_unparse_in_same_directory_as_input_file>;
26004};
26005template <> struct describe_field_t<SgProject,bool,&SgProject::p_stop_after_compilation_do_not_assemble_file> {
26006 using parent = SgProject;
26007 using field_type = bool;
26008 static constexpr size_t position{72};
26009 static constexpr char const * const name{"stop_after_compilation_do_not_assemble_file"};
26010 static constexpr char const * const typestr{"bool"};
26011 static constexpr bool traverse{false};
26012 static constexpr auto mbr_ptr{&SgProject::p_stop_after_compilation_do_not_assemble_file};
26013 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26014 using bind = Desc<SgProject, bool SgProject::*, &SgProject::p_stop_after_compilation_do_not_assemble_file>;
26015};
26016template <> struct describe_field_t<SgProject,std::string,&SgProject::p_gnuOptionForUndefinedSymbol> {
26017 using parent = SgProject;
26018 using field_type = std::string;
26019 static constexpr size_t position{73};
26020 static constexpr char const * const name{"gnuOptionForUndefinedSymbol"};
26021 static constexpr char const * const typestr{"std::string"};
26022 static constexpr bool traverse{false};
26023 static constexpr auto mbr_ptr{&SgProject::p_gnuOptionForUndefinedSymbol};
26024 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26025 using bind = Desc<SgProject, std::string SgProject::*, &SgProject::p_gnuOptionForUndefinedSymbol>;
26026};
26027template <> struct describe_field_t<SgProject,bool,&SgProject::p_mode_32_bit> {
26028 using parent = SgProject;
26029 using field_type = bool;
26030 static constexpr size_t position{74};
26031 static constexpr char const * const name{"mode_32_bit"};
26032 static constexpr char const * const typestr{"bool"};
26033 static constexpr bool traverse{false};
26034 static constexpr auto mbr_ptr{&SgProject::p_mode_32_bit};
26035 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26036 using bind = Desc<SgProject, bool SgProject::*, &SgProject::p_mode_32_bit>;
26037};
26038template <> struct describe_field_t<SgProject,bool,&SgProject::p_noclobber_output_file> {
26039 using parent = SgProject;
26040 using field_type = bool;
26041 static constexpr size_t position{75};
26042 static constexpr char const * const name{"noclobber_output_file"};
26043 static constexpr char const * const typestr{"bool"};
26044 static constexpr bool traverse{false};
26045 static constexpr auto mbr_ptr{&SgProject::p_noclobber_output_file};
26046 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26047 using bind = Desc<SgProject, bool SgProject::*, &SgProject::p_noclobber_output_file>;
26048};
26049template <> struct describe_field_t<SgProject,bool,&SgProject::p_noclobber_if_different_output_file> {
26050 using parent = SgProject;
26051 using field_type = bool;
26052 static constexpr size_t position{76};
26053 static constexpr char const * const name{"noclobber_if_different_output_file"};
26054 static constexpr char const * const typestr{"bool"};
26055 static constexpr bool traverse{false};
26056 static constexpr auto mbr_ptr{&SgProject::p_noclobber_if_different_output_file};
26057 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26058 using bind = Desc<SgProject, bool SgProject::*, &SgProject::p_noclobber_if_different_output_file>;
26059};
26060template <> struct describe_field_t<SgProject,bool,&SgProject::p_suppressConstantFoldingPostProcessing> {
26061 using parent = SgProject;
26062 using field_type = bool;
26063 static constexpr size_t position{77};
26064 static constexpr char const * const name{"suppressConstantFoldingPostProcessing"};
26065 static constexpr char const * const typestr{"bool"};
26066 static constexpr bool traverse{false};
26067 static constexpr auto mbr_ptr{&SgProject::p_suppressConstantFoldingPostProcessing};
26068 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26069 using bind = Desc<SgProject, bool SgProject::*, &SgProject::p_suppressConstantFoldingPostProcessing>;
26070};
26071template <> struct describe_field_t<SgProject,bool,&SgProject::p_appendPID> {
26072 using parent = SgProject;
26073 using field_type = bool;
26074 static constexpr size_t position{78};
26075 static constexpr char const * const name{"appendPID"};
26076 static constexpr char const * const typestr{"bool"};
26077 static constexpr bool traverse{false};
26078 static constexpr auto mbr_ptr{&SgProject::p_appendPID};
26079 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26080 using bind = Desc<SgProject, bool SgProject::*, &SgProject::p_appendPID>;
26081};
26082template <> struct describe_field_t<SgProject,bool,&SgProject::p_reportOnHeaderFileUnparsing> {
26083 using parent = SgProject;
26084 using field_type = bool;
26085 static constexpr size_t position{79};
26086 static constexpr char const * const name{"reportOnHeaderFileUnparsing"};
26087 static constexpr char const * const typestr{"bool"};
26088 static constexpr bool traverse{false};
26089 static constexpr auto mbr_ptr{&SgProject::p_reportOnHeaderFileUnparsing};
26090 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26091 using bind = Desc<SgProject, bool SgProject::*, &SgProject::p_reportOnHeaderFileUnparsing>;
26092};
26093template <> struct describe_field_t<SgProject,std::string,&SgProject::p_applicationRootDirectory> {
26094 using parent = SgProject;
26095 using field_type = std::string;
26096 static constexpr size_t position{80};
26097 static constexpr char const * const name{"applicationRootDirectory"};
26098 static constexpr char const * const typestr{"std::string"};
26099 static constexpr bool traverse{false};
26100 static constexpr auto mbr_ptr{&SgProject::p_applicationRootDirectory};
26101 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26102 using bind = Desc<SgProject, std::string SgProject::*, &SgProject::p_applicationRootDirectory>;
26103};
26104template <> struct describe_field_t<SgProject,bool,&SgProject::p_usingApplicationRootDirectory> {
26105 using parent = SgProject;
26106 using field_type = bool;
26107 static constexpr size_t position{81};
26108 static constexpr char const * const name{"usingApplicationRootDirectory"};
26109 static constexpr char const * const typestr{"bool"};
26110 static constexpr bool traverse{false};
26111 static constexpr auto mbr_ptr{&SgProject::p_usingApplicationRootDirectory};
26112 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26113 using bind = Desc<SgProject, bool SgProject::*, &SgProject::p_usingApplicationRootDirectory>;
26114};
26115template <> struct describe_field_t<SgProject,bool,&SgProject::p_usingDeferredTransformations> {
26116 using parent = SgProject;
26117 using field_type = bool;
26118 static constexpr size_t position{82};
26119 static constexpr char const * const name{"usingDeferredTransformations"};
26120 static constexpr char const * const typestr{"bool"};
26121 static constexpr bool traverse{false};
26122 static constexpr auto mbr_ptr{&SgProject::p_usingDeferredTransformations};
26123 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26124 using bind = Desc<SgProject, bool SgProject::*, &SgProject::p_usingDeferredTransformations>;
26125};
26126template <> struct describe_field_t<SgProject,std::string,&SgProject::p_astfile_out> {
26127 using parent = SgProject;
26128 using field_type = std::string;
26129 static constexpr size_t position{83};
26130 static constexpr char const * const name{"astfile_out"};
26131 static constexpr char const * const typestr{"std::string"};
26132 static constexpr bool traverse{false};
26133 static constexpr auto mbr_ptr{&SgProject::p_astfile_out};
26134 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26135 using bind = Desc<SgProject, std::string SgProject::*, &SgProject::p_astfile_out>;
26136};
26137template <> struct describe_field_t<SgProject,std::list<std::string>,&SgProject::p_astfiles_in> {
26138 using parent = SgProject;
26139 using field_type = std::list<std::string>;
26140 static constexpr size_t position{84};
26141 static constexpr char const * const name{"astfiles_in"};
26142 static constexpr char const * const typestr{"std::list<std::string>"};
26143 static constexpr bool traverse{false};
26144 static constexpr auto mbr_ptr{&SgProject::p_astfiles_in};
26145 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26146 using bind = Desc<SgProject, std::list<std::string> SgProject::*, &SgProject::p_astfiles_in>;
26147};
26148template <> struct describe_field_t<SgProject,SgStringList,&SgProject::p_extraIncludeDirectorySpecifierBeforeList> {
26149 using parent = SgProject;
26150 using field_type = SgStringList;
26151 static constexpr size_t position{85};
26152 static constexpr char const * const name{"extraIncludeDirectorySpecifierBeforeList"};
26153 static constexpr char const * const typestr{"SgStringList"};
26154 static constexpr bool traverse{false};
26155 static constexpr auto mbr_ptr{&SgProject::p_extraIncludeDirectorySpecifierBeforeList};
26156 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26157 using bind = Desc<SgProject, SgStringList SgProject::*, &SgProject::p_extraIncludeDirectorySpecifierBeforeList>;
26158};
26159template <> struct describe_field_t<SgProject,SgStringList,&SgProject::p_extraIncludeDirectorySpecifierAfterList> {
26160 using parent = SgProject;
26161 using field_type = SgStringList;
26162 static constexpr size_t position{86};
26163 static constexpr char const * const name{"extraIncludeDirectorySpecifierAfterList"};
26164 static constexpr char const * const typestr{"SgStringList"};
26165 static constexpr bool traverse{false};
26166 static constexpr auto mbr_ptr{&SgProject::p_extraIncludeDirectorySpecifierAfterList};
26167 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26168 using bind = Desc<SgProject, SgStringList SgProject::*, &SgProject::p_extraIncludeDirectorySpecifierAfterList>;
26169};
26170template <> struct describe_field_t<SgProject,bool,&SgProject::p_skip_post_processing> {
26171 using parent = SgProject;
26172 using field_type = bool;
26173 static constexpr size_t position{87};
26174 static constexpr char const * const name{"skip_post_processing"};
26175 static constexpr char const * const typestr{"bool"};
26176 static constexpr bool traverse{false};
26177 static constexpr auto mbr_ptr{&SgProject::p_skip_post_processing};
26178 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26179 using bind = Desc<SgProject, bool SgProject::*, &SgProject::p_skip_post_processing>;
26180};
26181template <> struct describe_node_t<SgProject> {
26182 using node = SgProject;
26183 using base = SgSupport;
26184 static constexpr char const * const name{"Project"};
26185 static constexpr unsigned long variant{657};
26186 static constexpr bool concrete{true};
26187 using subclasses_t = mp::List<>;
26188 using fields_t = mp::List<describe_field_t<SgProject,SgFileList*,&SgProject::p_fileList_ptr>, describe_field_t<SgProject,SgStringList,&SgProject::p_originalCommandLineArgumentList>, describe_field_t<SgProject,int,&SgProject::p_frontendErrorCode>, describe_field_t<SgProject,int,&SgProject::p_javacErrorCode>, describe_field_t<SgProject,int,&SgProject::p_ecjErrorCode>, describe_field_t<SgProject,int,&SgProject::p_midendErrorCode>, describe_field_t<SgProject,int,&SgProject::p_backendErrorCode>, describe_field_t<SgProject,bool,&SgProject::p_keep_going>, describe_field_t<SgProject,bool,&SgProject::p_unparser__clobber_input_file>, describe_field_t<SgProject,std::string,&SgProject::p_outputFileName>, describe_field_t<SgProject,SgStringList,&SgProject::p_sourceFileNameList>, describe_field_t<SgProject,SgStringList,&SgProject::p_objectFileNameList>, describe_field_t<SgProject,SgStringList,&SgProject::p_libraryFileList>, describe_field_t<SgProject,SgStringList,&SgProject::p_librarySpecifierList>, describe_field_t<SgProject,SgStringList,&SgProject::p_libraryDirectorySpecifierList>, describe_field_t<SgProject,SgStringList,&SgProject::p_includeDirectorySpecifierList>, describe_field_t<SgProject,SgStringList,&SgProject::p_macroSpecifierList>, describe_field_t<SgProject,SgStringList,&SgProject::p_preincludeFileList>, describe_field_t<SgProject,SgStringList,&SgProject::p_preincludeDirectoryList>, describe_field_t<SgProject,bool,&SgProject::p_compileOnly>, describe_field_t<SgProject,bool,&SgProject::p_wave>, describe_field_t<SgProject,bool,&SgProject::p_prelink>, describe_field_t<SgProject,SgProject::template_instantiation_enum,&SgProject::p_template_instantiation_mode>, describe_field_t<SgProject,bool,&SgProject::p_ast_merge>, describe_field_t<SgProject,std::string,&SgProject::p_projectSpecificDatabaseFile>, describe_field_t<SgProject,bool,&SgProject::p_C_PreprocessorOnly>, describe_field_t<SgProject,AstAttributeMechanism*,&SgProject::p_attributeMechanism>, describe_field_t<SgProject,std::string,&SgProject::p_compilationPerformanceFile>, describe_field_t<SgProject,SgStringList,&SgProject::p_includePathList>, describe_field_t<SgProject,SgStringList,&SgProject::p_excludePathList>, describe_field_t<SgProject,SgStringList,&SgProject::p_includeFileList>, describe_field_t<SgProject,SgStringList,&SgProject::p_excludeFileList>, describe_field_t<SgProject,bool,&SgProject::p_binary_only>, describe_field_t<SgProject,std::string,&SgProject::p_dataBaseFilename>, describe_field_t<SgProject,SgDirectoryList*,&SgProject::p_directoryList>, describe_field_t<SgProject,bool,&SgProject::p_C_only>, describe_field_t<SgProject,bool,&SgProject::p_Cxx_only>, describe_field_t<SgProject,bool,&SgProject::p_C11_only>, describe_field_t<SgProject,bool,&SgProject::p_Cxx0x_only>, describe_field_t<SgProject,bool,&SgProject::p_Cxx11_only>, describe_field_t<SgProject,bool,&SgProject::p_C14_only>, describe_field_t<SgProject,bool,&SgProject::p_Cxx14_only>, describe_field_t<SgProject,bool,&SgProject::p_Fortran_only>, describe_field_t<SgProject,std::list<std::string>,&SgProject::p_Fortran_ofp_jvm_options>, describe_field_t<SgProject,bool,&SgProject::p_Java_only>, describe_field_t<SgProject,bool,&SgProject::p_Jvm_only>, describe_field_t<SgProject,bool,&SgProject::p_Jovial_only>, describe_field_t<SgProject,bool,&SgProject::p_Ada_only>, describe_field_t<SgProject,bool,&SgProject::p_openmp_linking>, describe_field_t<SgProject,std::list<std::string>,&SgProject::p_Java_ecj_jvm_options>, describe_field_t<SgProject,bool,&SgProject::p_Java_batch_mode>, describe_field_t<SgProject,std::list<std::string>,&SgProject::p_Java_classpath>, describe_field_t<SgProject,std::list<std::string>,&SgProject::p_Java_sourcepath>, describe_field_t<SgProject,std::string,&SgProject::p_Java_destdir>, describe_field_t<SgProject,std::string,&SgProject::p_Java_source_destdir>, describe_field_t<SgProject,std::string,&SgProject::p_Java_s>, describe_field_t<SgProject,std::string,&SgProject::p_Java_source>, describe_field_t<SgProject,std::string,&SgProject::p_Java_target>, describe_field_t<SgProject,std::string,&SgProject::p_Java_encoding>, describe_field_t<SgProject,std::string,&SgProject::p_Java_g>, describe_field_t<SgProject,bool,&SgProject::p_Java_nowarn>, describe_field_t<SgProject,bool,&SgProject::p_Java_verbose>, describe_field_t<SgProject,bool,&SgProject::p_Java_deprecation>, describe_field_t<SgProject,std::list<std::string>,&SgProject::p_Java_bootclasspath>, describe_field_t<SgProject,bool,&SgProject::p_addCppDirectivesToAST>, describe_field_t<SgProject,std::map<std::string, std::set<PreprocessingInfo*> >,&SgProject::p_includingPreprocessingInfosMap>, describe_field_t<SgProject,std::list<std::string>,&SgProject::p_quotedIncludesSearchPaths>, describe_field_t<SgProject,std::list<std::string>,&SgProject::p_bracketedIncludesSearchPaths>, describe_field_t<SgProject,std::string,&SgProject::p_unparseHeaderFilesRootFolder>, describe_field_t<SgProject,bool,&SgProject::p_frontendConstantFolding>, describe_field_t<SgProject,SgGlobal*,&SgProject::p_globalScopeAcrossFiles>, describe_field_t<SgProject,bool,&SgProject::p_unparse_in_same_directory_as_input_file>, describe_field_t<SgProject,bool,&SgProject::p_stop_after_compilation_do_not_assemble_file>, describe_field_t<SgProject,std::string,&SgProject::p_gnuOptionForUndefinedSymbol>, describe_field_t<SgProject,bool,&SgProject::p_mode_32_bit>, describe_field_t<SgProject,bool,&SgProject::p_noclobber_output_file>, describe_field_t<SgProject,bool,&SgProject::p_noclobber_if_different_output_file>, describe_field_t<SgProject,bool,&SgProject::p_suppressConstantFoldingPostProcessing>, describe_field_t<SgProject,bool,&SgProject::p_appendPID>, describe_field_t<SgProject,bool,&SgProject::p_reportOnHeaderFileUnparsing>, describe_field_t<SgProject,std::string,&SgProject::p_applicationRootDirectory>, describe_field_t<SgProject,bool,&SgProject::p_usingApplicationRootDirectory>, describe_field_t<SgProject,bool,&SgProject::p_usingDeferredTransformations>, describe_field_t<SgProject,std::string,&SgProject::p_astfile_out>, describe_field_t<SgProject,std::list<std::string>,&SgProject::p_astfiles_in>, describe_field_t<SgProject,SgStringList,&SgProject::p_extraIncludeDirectorySpecifierBeforeList>, describe_field_t<SgProject,SgStringList,&SgProject::p_extraIncludeDirectorySpecifierAfterList>, describe_field_t<SgProject,bool,&SgProject::p_skip_post_processing>>;
26189};
26190template <> struct node_from_variant_t<657> { using type = SgProject; };
26191
26192// Class: PseudoDestructorRefExp
26193template <> struct describe_field_t<SgPseudoDestructorRefExp,SgType*,&SgPseudoDestructorRefExp::p_object_type> {
26195 using field_type = SgType*;
26196 static constexpr size_t position{0};
26197 static constexpr char const * const name{"object_type"};
26198 static constexpr char const * const typestr{"SgType*"};
26199 static constexpr bool traverse{false};
26200 static constexpr auto mbr_ptr{&SgPseudoDestructorRefExp::p_object_type};
26201 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26202 using bind = Desc<SgPseudoDestructorRefExp, SgType* SgPseudoDestructorRefExp::*, &SgPseudoDestructorRefExp::p_object_type>;
26203};
26204template <> struct describe_field_t<SgPseudoDestructorRefExp,SgType*,&SgPseudoDestructorRefExp::p_expression_type> {
26206 using field_type = SgType*;
26207 static constexpr size_t position{1};
26208 static constexpr char const * const name{"expression_type"};
26209 static constexpr char const * const typestr{"SgType*"};
26210 static constexpr bool traverse{false};
26211 static constexpr auto mbr_ptr{&SgPseudoDestructorRefExp::p_expression_type};
26212 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26213 using bind = Desc<SgPseudoDestructorRefExp, SgType* SgPseudoDestructorRefExp::*, &SgPseudoDestructorRefExp::p_expression_type>;
26214};
26215template <> struct describe_field_t<SgPseudoDestructorRefExp,int,&SgPseudoDestructorRefExp::p_name_qualification_length> {
26217 using field_type = int;
26218 static constexpr size_t position{2};
26219 static constexpr char const * const name{"name_qualification_length"};
26220 static constexpr char const * const typestr{"int"};
26221 static constexpr bool traverse{false};
26222 static constexpr auto mbr_ptr{&SgPseudoDestructorRefExp::p_name_qualification_length};
26223 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26224 using bind = Desc<SgPseudoDestructorRefExp, int SgPseudoDestructorRefExp::*, &SgPseudoDestructorRefExp::p_name_qualification_length>;
26225};
26226template <> struct describe_field_t<SgPseudoDestructorRefExp,bool,&SgPseudoDestructorRefExp::p_type_elaboration_required> {
26228 using field_type = bool;
26229 static constexpr size_t position{3};
26230 static constexpr char const * const name{"type_elaboration_required"};
26231 static constexpr char const * const typestr{"bool"};
26232 static constexpr bool traverse{false};
26233 static constexpr auto mbr_ptr{&SgPseudoDestructorRefExp::p_type_elaboration_required};
26234 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26235 using bind = Desc<SgPseudoDestructorRefExp, bool SgPseudoDestructorRefExp::*, &SgPseudoDestructorRefExp::p_type_elaboration_required>;
26236};
26237template <> struct describe_field_t<SgPseudoDestructorRefExp,bool,&SgPseudoDestructorRefExp::p_global_qualification_required> {
26239 using field_type = bool;
26240 static constexpr size_t position{4};
26241 static constexpr char const * const name{"global_qualification_required"};
26242 static constexpr char const * const typestr{"bool"};
26243 static constexpr bool traverse{false};
26244 static constexpr auto mbr_ptr{&SgPseudoDestructorRefExp::p_global_qualification_required};
26245 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26246 using bind = Desc<SgPseudoDestructorRefExp, bool SgPseudoDestructorRefExp::*, &SgPseudoDestructorRefExp::p_global_qualification_required>;
26247};
26257template <> struct node_from_variant_t<658> { using type = SgPseudoDestructorRefExp; };
26258
26259// Class: PythonGlobalStmt
26260template <> struct describe_field_t<SgPythonGlobalStmt,SgInitializedNamePtrList,&SgPythonGlobalStmt::p_names> {
26261 using parent = SgPythonGlobalStmt;
26262 using field_type = SgInitializedNamePtrList;
26263 static constexpr size_t position{0};
26264 static constexpr char const * const name{"names"};
26265 static constexpr char const * const typestr{"SgInitializedNamePtrList"};
26266 static constexpr bool traverse{true};
26267 static constexpr auto mbr_ptr{&SgPythonGlobalStmt::p_names};
26268 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26269 using bind = Desc<SgPythonGlobalStmt, SgInitializedNamePtrList SgPythonGlobalStmt::*, &SgPythonGlobalStmt::p_names>;
26270};
26272 using node = SgPythonGlobalStmt;
26273 using base = SgStatement;
26274 static constexpr char const * const name{"PythonGlobalStmt"};
26275 static constexpr unsigned long variant{659};
26276 static constexpr bool concrete{true};
26277 using subclasses_t = mp::List<>;
26279};
26280template <> struct node_from_variant_t<659> { using type = SgPythonGlobalStmt; };
26281
26282// Class: PythonPrintStmt
26283template <> struct describe_field_t<SgPythonPrintStmt,SgExpression*,&SgPythonPrintStmt::p_destination> {
26284 using parent = SgPythonPrintStmt;
26285 using field_type = SgExpression*;
26286 static constexpr size_t position{0};
26287 static constexpr char const * const name{"destination"};
26288 static constexpr char const * const typestr{"SgExpression*"};
26289 static constexpr bool traverse{true};
26290 static constexpr auto mbr_ptr{&SgPythonPrintStmt::p_destination};
26291 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26292 using bind = Desc<SgPythonPrintStmt, SgExpression* SgPythonPrintStmt::*, &SgPythonPrintStmt::p_destination>;
26293};
26294template <> struct describe_field_t<SgPythonPrintStmt,SgExprListExp*,&SgPythonPrintStmt::p_values> {
26295 using parent = SgPythonPrintStmt;
26296 using field_type = SgExprListExp*;
26297 static constexpr size_t position{1};
26298 static constexpr char const * const name{"values"};
26299 static constexpr char const * const typestr{"SgExprListExp*"};
26300 static constexpr bool traverse{true};
26301 static constexpr auto mbr_ptr{&SgPythonPrintStmt::p_values};
26302 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26303 using bind = Desc<SgPythonPrintStmt, SgExprListExp* SgPythonPrintStmt::*, &SgPythonPrintStmt::p_values>;
26304};
26306 using node = SgPythonPrintStmt;
26307 using base = SgStatement;
26308 static constexpr char const * const name{"PythonPrintStmt"};
26309 static constexpr unsigned long variant{660};
26310 static constexpr bool concrete{true};
26311 using subclasses_t = mp::List<>;
26313};
26314template <> struct node_from_variant_t<660> { using type = SgPythonPrintStmt; };
26315
26316// Class: QualifiedName
26317template <> struct describe_field_t<SgQualifiedName,SgScopeStatement*,&SgQualifiedName::p_scope> {
26318 using parent = SgQualifiedName;
26320 static constexpr size_t position{0};
26321 static constexpr char const * const name{"scope"};
26322 static constexpr char const * const typestr{"SgScopeStatement*"};
26323 static constexpr bool traverse{false};
26324 static constexpr auto mbr_ptr{&SgQualifiedName::p_scope};
26325 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26326 using bind = Desc<SgQualifiedName, SgScopeStatement* SgQualifiedName::*, &SgQualifiedName::p_scope>;
26327};
26329 using node = SgQualifiedName;
26330 using base = SgSupport;
26331 static constexpr char const * const name{"QualifiedName"};
26332 static constexpr unsigned long variant{661};
26333 static constexpr bool concrete{true};
26334 using subclasses_t = mp::List<>;
26336};
26337template <> struct node_from_variant_t<661> { using type = SgQualifiedName; };
26338
26339// Class: QualifiedNameType
26340template <> struct describe_field_t<SgQualifiedNameType,SgType*,&SgQualifiedNameType::p_base_type> {
26342 using field_type = SgType*;
26343 static constexpr size_t position{0};
26344 static constexpr char const * const name{"base_type"};
26345 static constexpr char const * const typestr{"SgType*"};
26346 static constexpr bool traverse{false};
26347 static constexpr auto mbr_ptr{&SgQualifiedNameType::p_base_type};
26348 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26349 using bind = Desc<SgQualifiedNameType, SgType* SgQualifiedNameType::*, &SgQualifiedNameType::p_base_type>;
26350};
26351template <> struct describe_field_t<SgQualifiedNameType,SgQualifiedNamePtrList,&SgQualifiedNameType::p_qualifiedNameList> {
26353 using field_type = SgQualifiedNamePtrList;
26354 static constexpr size_t position{1};
26355 static constexpr char const * const name{"qualifiedNameList"};
26356 static constexpr char const * const typestr{"SgQualifiedNamePtrList"};
26357 static constexpr bool traverse{false};
26358 static constexpr auto mbr_ptr{&SgQualifiedNameType::p_qualifiedNameList};
26359 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26360 using bind = Desc<SgQualifiedNameType, SgQualifiedNamePtrList SgQualifiedNameType::*, &SgQualifiedNameType::p_qualifiedNameList>;
26361};
26363 using node = SgQualifiedNameType;
26364 using base = SgType;
26365 static constexpr char const * const name{"QualifiedNameType"};
26366 static constexpr unsigned long variant{662};
26367 static constexpr bool concrete{true};
26368 using subclasses_t = mp::List<>;
26370};
26371template <> struct node_from_variant_t<662> { using type = SgQualifiedNameType; };
26372
26373// Class: RangeExp
26374template <> struct describe_field_t<SgRangeExp,SgExpression*,&SgRangeExp::p_start> {
26375 using parent = SgRangeExp;
26376 using field_type = SgExpression*;
26377 static constexpr size_t position{0};
26378 static constexpr char const * const name{"start"};
26379 static constexpr char const * const typestr{"SgExpression*"};
26380 static constexpr bool traverse{true};
26381 static constexpr auto mbr_ptr{&SgRangeExp::p_start};
26382 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26383 using bind = Desc<SgRangeExp, SgExpression* SgRangeExp::*, &SgRangeExp::p_start>;
26384};
26385template <> struct describe_field_t<SgRangeExp,SgExpression*,&SgRangeExp::p_end> {
26386 using parent = SgRangeExp;
26387 using field_type = SgExpression*;
26388 static constexpr size_t position{1};
26389 static constexpr char const * const name{"end"};
26390 static constexpr char const * const typestr{"SgExpression*"};
26391 static constexpr bool traverse{true};
26392 static constexpr auto mbr_ptr{&SgRangeExp::p_end};
26393 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26394 using bind = Desc<SgRangeExp, SgExpression* SgRangeExp::*, &SgRangeExp::p_end>;
26395};
26396template <> struct describe_field_t<SgRangeExp,SgExpression*,&SgRangeExp::p_stride> {
26397 using parent = SgRangeExp;
26398 using field_type = SgExpression*;
26399 static constexpr size_t position{2};
26400 static constexpr char const * const name{"stride"};
26401 static constexpr char const * const typestr{"SgExpression*"};
26402 static constexpr bool traverse{true};
26403 static constexpr auto mbr_ptr{&SgRangeExp::p_stride};
26404 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26405 using bind = Desc<SgRangeExp, SgExpression* SgRangeExp::*, &SgRangeExp::p_stride>;
26406};
26407template <> struct describe_node_t<SgRangeExp> {
26408 using node = SgRangeExp;
26409 using base = SgExpression;
26410 static constexpr char const * const name{"RangeExp"};
26411 static constexpr unsigned long variant{663};
26412 static constexpr bool concrete{true};
26413 using subclasses_t = mp::List<>;
26415};
26416template <> struct node_from_variant_t<663> { using type = SgRangeExp; };
26417
26418// Class: RangeBasedForStatement
26419template <> struct describe_field_t<SgRangeBasedForStatement,SgVariableDeclaration*,&SgRangeBasedForStatement::p_iterator_declaration> {
26422 static constexpr size_t position{0};
26423 static constexpr char const * const name{"iterator_declaration"};
26424 static constexpr char const * const typestr{"SgVariableDeclaration*"};
26425 static constexpr bool traverse{true};
26426 static constexpr auto mbr_ptr{&SgRangeBasedForStatement::p_iterator_declaration};
26427 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26428 using bind = Desc<SgRangeBasedForStatement, SgVariableDeclaration* SgRangeBasedForStatement::*, &SgRangeBasedForStatement::p_iterator_declaration>;
26429};
26430template <> struct describe_field_t<SgRangeBasedForStatement,SgVariableDeclaration*,&SgRangeBasedForStatement::p_range_declaration> {
26433 static constexpr size_t position{1};
26434 static constexpr char const * const name{"range_declaration"};
26435 static constexpr char const * const typestr{"SgVariableDeclaration*"};
26436 static constexpr bool traverse{true};
26437 static constexpr auto mbr_ptr{&SgRangeBasedForStatement::p_range_declaration};
26438 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26439 using bind = Desc<SgRangeBasedForStatement, SgVariableDeclaration* SgRangeBasedForStatement::*, &SgRangeBasedForStatement::p_range_declaration>;
26440};
26441template <> struct describe_field_t<SgRangeBasedForStatement,SgVariableDeclaration*,&SgRangeBasedForStatement::p_begin_declaration> {
26444 static constexpr size_t position{2};
26445 static constexpr char const * const name{"begin_declaration"};
26446 static constexpr char const * const typestr{"SgVariableDeclaration*"};
26447 static constexpr bool traverse{true};
26448 static constexpr auto mbr_ptr{&SgRangeBasedForStatement::p_begin_declaration};
26449 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26450 using bind = Desc<SgRangeBasedForStatement, SgVariableDeclaration* SgRangeBasedForStatement::*, &SgRangeBasedForStatement::p_begin_declaration>;
26451};
26452template <> struct describe_field_t<SgRangeBasedForStatement,SgVariableDeclaration*,&SgRangeBasedForStatement::p_end_declaration> {
26455 static constexpr size_t position{3};
26456 static constexpr char const * const name{"end_declaration"};
26457 static constexpr char const * const typestr{"SgVariableDeclaration*"};
26458 static constexpr bool traverse{true};
26459 static constexpr auto mbr_ptr{&SgRangeBasedForStatement::p_end_declaration};
26460 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26461 using bind = Desc<SgRangeBasedForStatement, SgVariableDeclaration* SgRangeBasedForStatement::*, &SgRangeBasedForStatement::p_end_declaration>;
26462};
26463template <> struct describe_field_t<SgRangeBasedForStatement,SgExpression*,&SgRangeBasedForStatement::p_not_equal_expression> {
26465 using field_type = SgExpression*;
26466 static constexpr size_t position{4};
26467 static constexpr char const * const name{"not_equal_expression"};
26468 static constexpr char const * const typestr{"SgExpression*"};
26469 static constexpr bool traverse{true};
26470 static constexpr auto mbr_ptr{&SgRangeBasedForStatement::p_not_equal_expression};
26471 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26472 using bind = Desc<SgRangeBasedForStatement, SgExpression* SgRangeBasedForStatement::*, &SgRangeBasedForStatement::p_not_equal_expression>;
26473};
26474template <> struct describe_field_t<SgRangeBasedForStatement,SgExpression*,&SgRangeBasedForStatement::p_increment_expression> {
26476 using field_type = SgExpression*;
26477 static constexpr size_t position{5};
26478 static constexpr char const * const name{"increment_expression"};
26479 static constexpr char const * const typestr{"SgExpression*"};
26480 static constexpr bool traverse{true};
26481 static constexpr auto mbr_ptr{&SgRangeBasedForStatement::p_increment_expression};
26482 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26483 using bind = Desc<SgRangeBasedForStatement, SgExpression* SgRangeBasedForStatement::*, &SgRangeBasedForStatement::p_increment_expression>;
26484};
26485template <> struct describe_field_t<SgRangeBasedForStatement,SgStatement*,&SgRangeBasedForStatement::p_loop_body> {
26487 using field_type = SgStatement*;
26488 static constexpr size_t position{6};
26489 static constexpr char const * const name{"loop_body"};
26490 static constexpr char const * const typestr{"SgStatement*"};
26491 static constexpr bool traverse{true};
26492 static constexpr auto mbr_ptr{&SgRangeBasedForStatement::p_loop_body};
26493 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26494 using bind = Desc<SgRangeBasedForStatement, SgStatement* SgRangeBasedForStatement::*, &SgRangeBasedForStatement::p_loop_body>;
26495};
26505template <> struct node_from_variant_t<664> { using type = SgRangeBasedForStatement; };
26506
26507// Class: ReadStatement
26508template <> struct describe_field_t<SgReadStatement,SgExpression*,&SgReadStatement::p_format> {
26509 using parent = SgReadStatement;
26510 using field_type = SgExpression*;
26511 static constexpr size_t position{0};
26512 static constexpr char const * const name{"format"};
26513 static constexpr char const * const typestr{"SgExpression*"};
26514 static constexpr bool traverse{true};
26515 static constexpr auto mbr_ptr{&SgReadStatement::p_format};
26516 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26517 using bind = Desc<SgReadStatement, SgExpression* SgReadStatement::*, &SgReadStatement::p_format>;
26518};
26519template <> struct describe_field_t<SgReadStatement,SgExpression*,&SgReadStatement::p_namelist> {
26520 using parent = SgReadStatement;
26521 using field_type = SgExpression*;
26522 static constexpr size_t position{1};
26523 static constexpr char const * const name{"namelist"};
26524 static constexpr char const * const typestr{"SgExpression*"};
26525 static constexpr bool traverse{true};
26526 static constexpr auto mbr_ptr{&SgReadStatement::p_namelist};
26527 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26528 using bind = Desc<SgReadStatement, SgExpression* SgReadStatement::*, &SgReadStatement::p_namelist>;
26529};
26530template <> struct describe_field_t<SgReadStatement,SgExpression*,&SgReadStatement::p_advance> {
26531 using parent = SgReadStatement;
26532 using field_type = SgExpression*;
26533 static constexpr size_t position{2};
26534 static constexpr char const * const name{"advance"};
26535 static constexpr char const * const typestr{"SgExpression*"};
26536 static constexpr bool traverse{true};
26537 static constexpr auto mbr_ptr{&SgReadStatement::p_advance};
26538 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26539 using bind = Desc<SgReadStatement, SgExpression* SgReadStatement::*, &SgReadStatement::p_advance>;
26540};
26541template <> struct describe_field_t<SgReadStatement,SgExpression*,&SgReadStatement::p_asynchronous> {
26542 using parent = SgReadStatement;
26543 using field_type = SgExpression*;
26544 static constexpr size_t position{3};
26545 static constexpr char const * const name{"asynchronous"};
26546 static constexpr char const * const typestr{"SgExpression*"};
26547 static constexpr bool traverse{true};
26548 static constexpr auto mbr_ptr{&SgReadStatement::p_asynchronous};
26549 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26550 using bind = Desc<SgReadStatement, SgExpression* SgReadStatement::*, &SgReadStatement::p_asynchronous>;
26551};
26552template <> struct describe_field_t<SgReadStatement,SgExpression*,&SgReadStatement::p_blank> {
26553 using parent = SgReadStatement;
26554 using field_type = SgExpression*;
26555 static constexpr size_t position{4};
26556 static constexpr char const * const name{"blank"};
26557 static constexpr char const * const typestr{"SgExpression*"};
26558 static constexpr bool traverse{true};
26559 static constexpr auto mbr_ptr{&SgReadStatement::p_blank};
26560 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26561 using bind = Desc<SgReadStatement, SgExpression* SgReadStatement::*, &SgReadStatement::p_blank>;
26562};
26563template <> struct describe_field_t<SgReadStatement,SgExpression*,&SgReadStatement::p_decimal> {
26564 using parent = SgReadStatement;
26565 using field_type = SgExpression*;
26566 static constexpr size_t position{5};
26567 static constexpr char const * const name{"decimal"};
26568 static constexpr char const * const typestr{"SgExpression*"};
26569 static constexpr bool traverse{true};
26570 static constexpr auto mbr_ptr{&SgReadStatement::p_decimal};
26571 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26572 using bind = Desc<SgReadStatement, SgExpression* SgReadStatement::*, &SgReadStatement::p_decimal>;
26573};
26574template <> struct describe_field_t<SgReadStatement,SgExpression*,&SgReadStatement::p_delim> {
26575 using parent = SgReadStatement;
26576 using field_type = SgExpression*;
26577 static constexpr size_t position{6};
26578 static constexpr char const * const name{"delim"};
26579 static constexpr char const * const typestr{"SgExpression*"};
26580 static constexpr bool traverse{true};
26581 static constexpr auto mbr_ptr{&SgReadStatement::p_delim};
26582 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26583 using bind = Desc<SgReadStatement, SgExpression* SgReadStatement::*, &SgReadStatement::p_delim>;
26584};
26585template <> struct describe_field_t<SgReadStatement,SgExpression*,&SgReadStatement::p_end> {
26586 using parent = SgReadStatement;
26587 using field_type = SgExpression*;
26588 static constexpr size_t position{7};
26589 static constexpr char const * const name{"end"};
26590 static constexpr char const * const typestr{"SgExpression*"};
26591 static constexpr bool traverse{true};
26592 static constexpr auto mbr_ptr{&SgReadStatement::p_end};
26593 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26594 using bind = Desc<SgReadStatement, SgExpression* SgReadStatement::*, &SgReadStatement::p_end>;
26595};
26596template <> struct describe_field_t<SgReadStatement,SgExpression*,&SgReadStatement::p_eor> {
26597 using parent = SgReadStatement;
26598 using field_type = SgExpression*;
26599 static constexpr size_t position{8};
26600 static constexpr char const * const name{"eor"};
26601 static constexpr char const * const typestr{"SgExpression*"};
26602 static constexpr bool traverse{true};
26603 static constexpr auto mbr_ptr{&SgReadStatement::p_eor};
26604 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26605 using bind = Desc<SgReadStatement, SgExpression* SgReadStatement::*, &SgReadStatement::p_eor>;
26606};
26607template <> struct describe_field_t<SgReadStatement,SgExpression*,&SgReadStatement::p_id> {
26608 using parent = SgReadStatement;
26609 using field_type = SgExpression*;
26610 static constexpr size_t position{9};
26611 static constexpr char const * const name{"id"};
26612 static constexpr char const * const typestr{"SgExpression*"};
26613 static constexpr bool traverse{true};
26614 static constexpr auto mbr_ptr{&SgReadStatement::p_id};
26615 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26616 using bind = Desc<SgReadStatement, SgExpression* SgReadStatement::*, &SgReadStatement::p_id>;
26617};
26618template <> struct describe_field_t<SgReadStatement,SgExpression*,&SgReadStatement::p_pad> {
26619 using parent = SgReadStatement;
26620 using field_type = SgExpression*;
26621 static constexpr size_t position{10};
26622 static constexpr char const * const name{"pad"};
26623 static constexpr char const * const typestr{"SgExpression*"};
26624 static constexpr bool traverse{true};
26625 static constexpr auto mbr_ptr{&SgReadStatement::p_pad};
26626 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26627 using bind = Desc<SgReadStatement, SgExpression* SgReadStatement::*, &SgReadStatement::p_pad>;
26628};
26629template <> struct describe_field_t<SgReadStatement,SgExpression*,&SgReadStatement::p_pos> {
26630 using parent = SgReadStatement;
26631 using field_type = SgExpression*;
26632 static constexpr size_t position{11};
26633 static constexpr char const * const name{"pos"};
26634 static constexpr char const * const typestr{"SgExpression*"};
26635 static constexpr bool traverse{true};
26636 static constexpr auto mbr_ptr{&SgReadStatement::p_pos};
26637 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26638 using bind = Desc<SgReadStatement, SgExpression* SgReadStatement::*, &SgReadStatement::p_pos>;
26639};
26640template <> struct describe_field_t<SgReadStatement,SgExpression*,&SgReadStatement::p_rec> {
26641 using parent = SgReadStatement;
26642 using field_type = SgExpression*;
26643 static constexpr size_t position{12};
26644 static constexpr char const * const name{"rec"};
26645 static constexpr char const * const typestr{"SgExpression*"};
26646 static constexpr bool traverse{true};
26647 static constexpr auto mbr_ptr{&SgReadStatement::p_rec};
26648 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26649 using bind = Desc<SgReadStatement, SgExpression* SgReadStatement::*, &SgReadStatement::p_rec>;
26650};
26651template <> struct describe_field_t<SgReadStatement,SgExpression*,&SgReadStatement::p_round> {
26652 using parent = SgReadStatement;
26653 using field_type = SgExpression*;
26654 static constexpr size_t position{13};
26655 static constexpr char const * const name{"round"};
26656 static constexpr char const * const typestr{"SgExpression*"};
26657 static constexpr bool traverse{true};
26658 static constexpr auto mbr_ptr{&SgReadStatement::p_round};
26659 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26660 using bind = Desc<SgReadStatement, SgExpression* SgReadStatement::*, &SgReadStatement::p_round>;
26661};
26662template <> struct describe_field_t<SgReadStatement,SgExpression*,&SgReadStatement::p_sign> {
26663 using parent = SgReadStatement;
26664 using field_type = SgExpression*;
26665 static constexpr size_t position{14};
26666 static constexpr char const * const name{"sign"};
26667 static constexpr char const * const typestr{"SgExpression*"};
26668 static constexpr bool traverse{true};
26669 static constexpr auto mbr_ptr{&SgReadStatement::p_sign};
26670 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26671 using bind = Desc<SgReadStatement, SgExpression* SgReadStatement::*, &SgReadStatement::p_sign>;
26672};
26673template <> struct describe_field_t<SgReadStatement,SgExpression*,&SgReadStatement::p_size> {
26674 using parent = SgReadStatement;
26675 using field_type = SgExpression*;
26676 static constexpr size_t position{15};
26677 static constexpr char const * const name{"size"};
26678 static constexpr char const * const typestr{"SgExpression*"};
26679 static constexpr bool traverse{true};
26680 static constexpr auto mbr_ptr{&SgReadStatement::p_size};
26681 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26682 using bind = Desc<SgReadStatement, SgExpression* SgReadStatement::*, &SgReadStatement::p_size>;
26683};
26685 using node = SgReadStatement;
26686 using base = SgIOStatement;
26687 static constexpr char const * const name{"ReadStatement"};
26688 static constexpr unsigned long variant{665};
26689 static constexpr bool concrete{true};
26690 using subclasses_t = mp::List<>;
26692};
26693template <> struct node_from_variant_t<665> { using type = SgReadStatement; };
26694
26695// Class: RealPartOp
26696template <> struct describe_node_t<SgRealPartOp> {
26697 using node = SgRealPartOp;
26698 using base = SgUnaryOp;
26699 static constexpr char const * const name{"RealPartOp"};
26700 static constexpr unsigned long variant{666};
26701 static constexpr bool concrete{true};
26702 using subclasses_t = mp::List<>;
26703 using fields_t = mp::List<>;
26704};
26705template <> struct node_from_variant_t<666> { using type = SgRealPartOp; };
26706
26707// Class: RefExp
26709 using parent = SgRefExp;
26710 using field_type = SgType*;
26711 static constexpr size_t position{0};
26712 static constexpr char const * const name{"type_name"};
26713 static constexpr char const * const typestr{"SgType*"};
26714 static constexpr bool traverse{false};
26715 static constexpr auto mbr_ptr{&SgRefExp::p_type_name};
26716 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26717 using bind = Desc<SgRefExp, SgType* SgRefExp::*, &SgRefExp::p_type_name>;
26718};
26719template <> struct describe_node_t<SgRefExp> {
26720 using node = SgRefExp;
26721 using base = SgExpression;
26722 static constexpr char const * const name{"RefExp"};
26723 static constexpr unsigned long variant{667};
26724 static constexpr bool concrete{true};
26725 using subclasses_t = mp::List<>;
26727};
26728template <> struct node_from_variant_t<667> { using type = SgRefExp; };
26729
26730// Class: ReferenceType
26731template <> struct describe_field_t<SgReferenceType,SgType*,&SgReferenceType::p_base_type> {
26732 using parent = SgReferenceType;
26733 using field_type = SgType*;
26734 static constexpr size_t position{0};
26735 static constexpr char const * const name{"base_type"};
26736 static constexpr char const * const typestr{"SgType*"};
26737 static constexpr bool traverse{false};
26738 static constexpr auto mbr_ptr{&SgReferenceType::p_base_type};
26739 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26740 using bind = Desc<SgReferenceType, SgType* SgReferenceType::*, &SgReferenceType::p_base_type>;
26741};
26743 using node = SgReferenceType;
26744 using base = SgType;
26745 static constexpr char const * const name{"ReferenceType"};
26746 static constexpr unsigned long variant{668};
26747 static constexpr bool concrete{true};
26748 using subclasses_t = mp::List<>;
26750};
26751template <> struct node_from_variant_t<668> { using type = SgReferenceType; };
26752
26753// Class: RemOp
26754template <> struct describe_node_t<SgRemOp> {
26755 using node = SgRemOp;
26756 using base = SgBinaryOp;
26757 static constexpr char const * const name{"RemOp"};
26758 static constexpr unsigned long variant{669};
26759 static constexpr bool concrete{true};
26760 using subclasses_t = mp::List<>;
26761 using fields_t = mp::List<>;
26762};
26763template <> struct node_from_variant_t<669> { using type = SgRemOp; };
26764
26765// Class: RenamePair
26766template <> struct describe_field_t<SgRenamePair,SgName,&SgRenamePair::p_local_name> {
26767 using parent = SgRenamePair;
26768 using field_type = SgName;
26769 static constexpr size_t position{0};
26770 static constexpr char const * const name{"local_name"};
26771 static constexpr char const * const typestr{"SgName"};
26772 static constexpr bool traverse{false};
26773 static constexpr auto mbr_ptr{&SgRenamePair::p_local_name};
26774 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26775 using bind = Desc<SgRenamePair, SgName SgRenamePair::*, &SgRenamePair::p_local_name>;
26776};
26777template <> struct describe_field_t<SgRenamePair,SgName,&SgRenamePair::p_use_name> {
26778 using parent = SgRenamePair;
26779 using field_type = SgName;
26780 static constexpr size_t position{1};
26781 static constexpr char const * const name{"use_name"};
26782 static constexpr char const * const typestr{"SgName"};
26783 static constexpr bool traverse{false};
26784 static constexpr auto mbr_ptr{&SgRenamePair::p_use_name};
26785 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26786 using bind = Desc<SgRenamePair, SgName SgRenamePair::*, &SgRenamePair::p_use_name>;
26787};
26788template <> struct describe_node_t<SgRenamePair> {
26789 using node = SgRenamePair;
26790 using base = SgLocatedNodeSupport;
26791 static constexpr char const * const name{"RenamePair"};
26792 static constexpr unsigned long variant{670};
26793 static constexpr bool concrete{true};
26794 using subclasses_t = mp::List<>;
26796};
26797template <> struct node_from_variant_t<670> { using type = SgRenamePair; };
26798
26799// Class: RenameSymbol
26800template <> struct describe_field_t<SgRenameSymbol,SgSymbol*,&SgRenameSymbol::p_original_symbol> {
26801 using parent = SgRenameSymbol;
26802 using field_type = SgSymbol*;
26803 static constexpr size_t position{0};
26804 static constexpr char const * const name{"original_symbol"};
26805 static constexpr char const * const typestr{"SgSymbol*"};
26806 static constexpr bool traverse{true};
26807 static constexpr auto mbr_ptr{&SgRenameSymbol::p_original_symbol};
26808 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26809 using bind = Desc<SgRenameSymbol, SgSymbol* SgRenameSymbol::*, &SgRenameSymbol::p_original_symbol>;
26810};
26811template <> struct describe_field_t<SgRenameSymbol,SgName,&SgRenameSymbol::p_new_name> {
26812 using parent = SgRenameSymbol;
26813 using field_type = SgName;
26814 static constexpr size_t position{1};
26815 static constexpr char const * const name{"new_name"};
26816 static constexpr char const * const typestr{"SgName"};
26817 static constexpr bool traverse{false};
26818 static constexpr auto mbr_ptr{&SgRenameSymbol::p_new_name};
26819 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26820 using bind = Desc<SgRenameSymbol, SgName SgRenameSymbol::*, &SgRenameSymbol::p_new_name>;
26821};
26822template <> struct describe_node_t<SgRenameSymbol> {
26823 using node = SgRenameSymbol;
26824 using base = SgFunctionSymbol;
26825 static constexpr char const * const name{"RenameSymbol"};
26826 static constexpr unsigned long variant{671};
26827 static constexpr bool concrete{true};
26828 using subclasses_t = mp::List<>;
26830};
26831template <> struct node_from_variant_t<671> { using type = SgRenameSymbol; };
26832
26833// Class: ReplicationOp
26835 using node = SgReplicationOp;
26836 using base = SgBinaryOp;
26837 static constexpr char const * const name{"ReplicationOp"};
26838 static constexpr unsigned long variant{672};
26839 static constexpr bool concrete{true};
26840 using subclasses_t = mp::List<>;
26841 using fields_t = mp::List<>;
26842};
26843template <> struct node_from_variant_t<672> { using type = SgReplicationOp; };
26844
26845// Class: ReturnStmt
26846template <> struct describe_field_t<SgReturnStmt,SgExpression*,&SgReturnStmt::p_expression> {
26847 using parent = SgReturnStmt;
26848 using field_type = SgExpression*;
26849 static constexpr size_t position{0};
26850 static constexpr char const * const name{"expression"};
26851 static constexpr char const * const typestr{"SgExpression*"};
26852 static constexpr bool traverse{true};
26853 static constexpr auto mbr_ptr{&SgReturnStmt::p_expression};
26854 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26855 using bind = Desc<SgReturnStmt, SgExpression* SgReturnStmt::*, &SgReturnStmt::p_expression>;
26856};
26857template <> struct describe_node_t<SgReturnStmt> {
26858 using node = SgReturnStmt;
26859 using base = SgStatement;
26860 static constexpr char const * const name{"ReturnStmt"};
26861 static constexpr unsigned long variant{673};
26862 static constexpr bool concrete{true};
26863 using subclasses_t = mp::List<>;
26865};
26866template <> struct node_from_variant_t<673> { using type = SgReturnStmt; };
26867
26868// Class: RewindStatement
26870 using node = SgRewindStatement;
26871 using base = SgIOStatement;
26872 static constexpr char const * const name{"RewindStatement"};
26873 static constexpr unsigned long variant{674};
26874 static constexpr bool concrete{true};
26875 using subclasses_t = mp::List<>;
26876 using fields_t = mp::List<>;
26877};
26878template <> struct node_from_variant_t<674> { using type = SgRewindStatement; };
26879
26880// Class: RshiftAssignOp
26882 using node = SgRshiftAssignOp;
26883 using base = SgCompoundAssignOp;
26884 static constexpr char const * const name{"RshiftAssignOp"};
26885 static constexpr unsigned long variant{675};
26886 static constexpr bool concrete{true};
26887 using subclasses_t = mp::List<>;
26888 using fields_t = mp::List<>;
26889};
26890template <> struct node_from_variant_t<675> { using type = SgRshiftAssignOp; };
26891
26892// Class: RshiftOp
26893template <> struct describe_node_t<SgRshiftOp> {
26894 using node = SgRshiftOp;
26895 using base = SgBinaryOp;
26896 static constexpr char const * const name{"RshiftOp"};
26897 static constexpr unsigned long variant{676};
26898 static constexpr bool concrete{true};
26899 using subclasses_t = mp::List<>;
26900 using fields_t = mp::List<>;
26901};
26902template <> struct node_from_variant_t<676> { using type = SgRshiftOp; };
26903
26904// Class: RvalueReferenceType
26905template <> struct describe_field_t<SgRvalueReferenceType,SgType*,&SgRvalueReferenceType::p_base_type> {
26907 using field_type = SgType*;
26908 static constexpr size_t position{0};
26909 static constexpr char const * const name{"base_type"};
26910 static constexpr char const * const typestr{"SgType*"};
26911 static constexpr bool traverse{false};
26912 static constexpr auto mbr_ptr{&SgRvalueReferenceType::p_base_type};
26913 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26914 using bind = Desc<SgRvalueReferenceType, SgType* SgRvalueReferenceType::*, &SgRvalueReferenceType::p_base_type>;
26915};
26918 using base = SgType;
26919 static constexpr char const * const name{"RvalueReferenceType"};
26920 static constexpr unsigned long variant{677};
26921 static constexpr bool concrete{true};
26922 using subclasses_t = mp::List<>;
26924};
26925template <> struct node_from_variant_t<677> { using type = SgRvalueReferenceType; };
26926
26927// Class: JavaUnsignedRshiftAssignOp
26930 using base = SgCompoundAssignOp;
26931 static constexpr char const * const name{"JavaUnsignedRshiftAssignOp"};
26932 static constexpr unsigned long variant{678};
26933 static constexpr bool concrete{true};
26934 using subclasses_t = mp::List<>;
26935 using fields_t = mp::List<>;
26936};
26937template <> struct node_from_variant_t<678> { using type = SgJavaUnsignedRshiftAssignOp; };
26938
26939// Class: JavaUnsignedRshiftOp
26942 using base = SgBinaryOp;
26943 static constexpr char const * const name{"JavaUnsignedRshiftOp"};
26944 static constexpr unsigned long variant{679};
26945 static constexpr bool concrete{true};
26946 using subclasses_t = mp::List<>;
26947 using fields_t = mp::List<>;
26948};
26949template <> struct node_from_variant_t<679> { using type = SgJavaUnsignedRshiftOp; };
26950
26951// Class: ScopeOp
26952template <> struct describe_node_t<SgScopeOp> {
26953 using node = SgScopeOp;
26954 using base = SgBinaryOp;
26955 static constexpr char const * const name{"ScopeOp"};
26956 static constexpr unsigned long variant{680};
26957 static constexpr bool concrete{true};
26958 using subclasses_t = mp::List<>;
26959 using fields_t = mp::List<>;
26960};
26961template <> struct node_from_variant_t<680> { using type = SgScopeOp; };
26962
26963// Class: ScopeStatement
26965 using parent = SgScopeStatement;
26966 using field_type = SgSymbolTable*;
26967 static constexpr size_t position{0};
26968 static constexpr char const * const name{"symbol_table"};
26969 static constexpr char const * const typestr{"SgSymbolTable*"};
26970 static constexpr bool traverse{false};
26971 static constexpr auto mbr_ptr{&SgScopeStatement::p_symbol_table};
26972 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26973 using bind = Desc<SgScopeStatement, SgSymbolTable* SgScopeStatement::*, &SgScopeStatement::p_symbol_table>;
26974};
26975template <> struct describe_field_t<SgScopeStatement,SgTypeTable*,&SgScopeStatement::p_type_table> {
26976 using parent = SgScopeStatement;
26977 using field_type = SgTypeTable*;
26978 static constexpr size_t position{1};
26979 static constexpr char const * const name{"type_table"};
26980 static constexpr char const * const typestr{"SgTypeTable*"};
26981 static constexpr bool traverse{false};
26982 static constexpr auto mbr_ptr{&SgScopeStatement::p_type_table};
26983 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26984 using bind = Desc<SgScopeStatement, SgTypeTable* SgScopeStatement::*, &SgScopeStatement::p_type_table>;
26985};
26986template <> struct describe_field_t<SgScopeStatement,std::set<SgSymbol*>,&SgScopeStatement::p_type_elaboration_list> {
26987 using parent = SgScopeStatement;
26988 using field_type = std::set<SgSymbol*>;
26989 static constexpr size_t position{2};
26990 static constexpr char const * const name{"type_elaboration_list"};
26991 static constexpr char const * const typestr{"std::set<SgSymbol*>"};
26992 static constexpr bool traverse{false};
26993 static constexpr auto mbr_ptr{&SgScopeStatement::p_type_elaboration_list};
26994 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
26995 using bind = Desc<SgScopeStatement, std::set<SgSymbol*> SgScopeStatement::*, &SgScopeStatement::p_type_elaboration_list>;
26996};
26997template <> struct describe_field_t<SgScopeStatement,std::set<SgSymbol*>,&SgScopeStatement::p_hidden_type_list> {
26998 using parent = SgScopeStatement;
26999 using field_type = std::set<SgSymbol*>;
27000 static constexpr size_t position{3};
27001 static constexpr char const * const name{"hidden_type_list"};
27002 static constexpr char const * const typestr{"std::set<SgSymbol*>"};
27003 static constexpr bool traverse{false};
27004 static constexpr auto mbr_ptr{&SgScopeStatement::p_hidden_type_list};
27005 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27006 using bind = Desc<SgScopeStatement, std::set<SgSymbol*> SgScopeStatement::*, &SgScopeStatement::p_hidden_type_list>;
27007};
27008template <> struct describe_field_t<SgScopeStatement,std::set<SgSymbol*>,&SgScopeStatement::p_hidden_declaration_list> {
27009 using parent = SgScopeStatement;
27010 using field_type = std::set<SgSymbol*>;
27011 static constexpr size_t position{4};
27012 static constexpr char const * const name{"hidden_declaration_list"};
27013 static constexpr char const * const typestr{"std::set<SgSymbol*>"};
27014 static constexpr bool traverse{false};
27015 static constexpr auto mbr_ptr{&SgScopeStatement::p_hidden_declaration_list};
27016 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27017 using bind = Desc<SgScopeStatement, std::set<SgSymbol*> SgScopeStatement::*, &SgScopeStatement::p_hidden_declaration_list>;
27018};
27019template <> struct describe_field_t<SgScopeStatement,SgPragma*,&SgScopeStatement::p_pragma> {
27020 using parent = SgScopeStatement;
27021 using field_type = SgPragma*;
27022 static constexpr size_t position{5};
27023 static constexpr char const * const name{"pragma"};
27024 static constexpr char const * const typestr{"SgPragma*"};
27025 static constexpr bool traverse{false};
27026 static constexpr auto mbr_ptr{&SgScopeStatement::p_pragma};
27027 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27028 using bind = Desc<SgScopeStatement, SgPragma* SgScopeStatement::*, &SgScopeStatement::p_pragma>;
27029};
27031 using node = SgScopeStatement;
27032 using base = SgStatement;
27033 static constexpr char const * const name{"ScopeStatement"};
27034 static constexpr unsigned long variant{681};
27035 static constexpr bool concrete{false};
27038};
27039template <> struct node_from_variant_t<681> { using type = SgScopeStatement; };
27040
27041// Class: SequenceStatement
27043 using node = SgSequenceStatement;
27044 using base = SgStatement;
27045 static constexpr char const * const name{"SequenceStatement"};
27046 static constexpr unsigned long variant{682};
27047 static constexpr bool concrete{true};
27048 using subclasses_t = mp::List<>;
27049 using fields_t = mp::List<>;
27050};
27051template <> struct node_from_variant_t<682> { using type = SgSequenceStatement; };
27052
27053// Class: SetComprehension
27054template <> struct describe_field_t<SgSetComprehension,SgExpression*,&SgSetComprehension::p_element> {
27055 using parent = SgSetComprehension;
27056 using field_type = SgExpression*;
27057 static constexpr size_t position{0};
27058 static constexpr char const * const name{"element"};
27059 static constexpr char const * const typestr{"SgExpression*"};
27060 static constexpr bool traverse{true};
27061 static constexpr auto mbr_ptr{&SgSetComprehension::p_element};
27062 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27063 using bind = Desc<SgSetComprehension, SgExpression* SgSetComprehension::*, &SgSetComprehension::p_element>;
27064};
27065template <> struct describe_field_t<SgSetComprehension,SgExprListExp*,&SgSetComprehension::p_generators> {
27066 using parent = SgSetComprehension;
27067 using field_type = SgExprListExp*;
27068 static constexpr size_t position{1};
27069 static constexpr char const * const name{"generators"};
27070 static constexpr char const * const typestr{"SgExprListExp*"};
27071 static constexpr bool traverse{true};
27072 static constexpr auto mbr_ptr{&SgSetComprehension::p_generators};
27073 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27074 using bind = Desc<SgSetComprehension, SgExprListExp* SgSetComprehension::*, &SgSetComprehension::p_generators>;
27075};
27077 using node = SgSetComprehension;
27078 using base = SgExpression;
27079 static constexpr char const * const name{"SetComprehension"};
27080 static constexpr unsigned long variant{683};
27081 static constexpr bool concrete{true};
27082 using subclasses_t = mp::List<>;
27084};
27085template <> struct node_from_variant_t<683> { using type = SgSetComprehension; };
27086
27087// Class: ShortVal
27088template <> struct describe_field_t<SgShortVal,short,&SgShortVal::p_value> {
27089 using parent = SgShortVal;
27090 using field_type = short;
27091 static constexpr size_t position{0};
27092 static constexpr char const * const name{"value"};
27093 static constexpr char const * const typestr{"short"};
27094 static constexpr bool traverse{false};
27095 static constexpr auto mbr_ptr{&SgShortVal::p_value};
27096 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27097 using bind = Desc<SgShortVal, short SgShortVal::*, &SgShortVal::p_value>;
27098};
27099template <> struct describe_field_t<SgShortVal,std::string,&SgShortVal::p_valueString> {
27100 using parent = SgShortVal;
27101 using field_type = std::string;
27102 static constexpr size_t position{1};
27103 static constexpr char const * const name{"valueString"};
27104 static constexpr char const * const typestr{"std::string"};
27105 static constexpr bool traverse{false};
27106 static constexpr auto mbr_ptr{&SgShortVal::p_valueString};
27107 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27108 using bind = Desc<SgShortVal, std::string SgShortVal::*, &SgShortVal::p_valueString>;
27109};
27110template <> struct describe_node_t<SgShortVal> {
27111 using node = SgShortVal;
27112 using base = SgValueExp;
27113 static constexpr char const * const name{"ShortVal"};
27114 static constexpr unsigned long variant{684};
27115 static constexpr bool concrete{true};
27116 using subclasses_t = mp::List<>;
27118};
27119template <> struct node_from_variant_t<684> { using type = SgShortVal; };
27120
27121// Class: SizeOfOp
27123 using parent = SgSizeOfOp;
27124 using field_type = SgExpression*;
27125 static constexpr size_t position{0};
27126 static constexpr char const * const name{"operand_expr"};
27127 static constexpr char const * const typestr{"SgExpression*"};
27128 static constexpr bool traverse{true};
27129 static constexpr auto mbr_ptr{&SgSizeOfOp::p_operand_expr};
27130 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27131 using bind = Desc<SgSizeOfOp, SgExpression* SgSizeOfOp::*, &SgSizeOfOp::p_operand_expr>;
27132};
27134 using parent = SgSizeOfOp;
27135 using field_type = SgType*;
27136 static constexpr size_t position{1};
27137 static constexpr char const * const name{"operand_type"};
27138 static constexpr char const * const typestr{"SgType*"};
27139 static constexpr bool traverse{false};
27140 static constexpr auto mbr_ptr{&SgSizeOfOp::p_operand_type};
27141 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27142 using bind = Desc<SgSizeOfOp, SgType* SgSizeOfOp::*, &SgSizeOfOp::p_operand_type>;
27143};
27145 using parent = SgSizeOfOp;
27146 using field_type = SgType*;
27147 static constexpr size_t position{2};
27148 static constexpr char const * const name{"expression_type"};
27149 static constexpr char const * const typestr{"SgType*"};
27150 static constexpr bool traverse{false};
27151 static constexpr auto mbr_ptr{&SgSizeOfOp::p_expression_type};
27152 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27153 using bind = Desc<SgSizeOfOp, SgType* SgSizeOfOp::*, &SgSizeOfOp::p_expression_type>;
27154};
27155template <> struct describe_field_t<SgSizeOfOp,int,&SgSizeOfOp::p_name_qualification_length> {
27156 using parent = SgSizeOfOp;
27157 using field_type = int;
27158 static constexpr size_t position{3};
27159 static constexpr char const * const name{"name_qualification_length"};
27160 static constexpr char const * const typestr{"int"};
27161 static constexpr bool traverse{false};
27162 static constexpr auto mbr_ptr{&SgSizeOfOp::p_name_qualification_length};
27163 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27164 using bind = Desc<SgSizeOfOp, int SgSizeOfOp::*, &SgSizeOfOp::p_name_qualification_length>;
27165};
27166template <> struct describe_field_t<SgSizeOfOp,bool,&SgSizeOfOp::p_type_elaboration_required> {
27167 using parent = SgSizeOfOp;
27168 using field_type = bool;
27169 static constexpr size_t position{4};
27170 static constexpr char const * const name{"type_elaboration_required"};
27171 static constexpr char const * const typestr{"bool"};
27172 static constexpr bool traverse{false};
27173 static constexpr auto mbr_ptr{&SgSizeOfOp::p_type_elaboration_required};
27174 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27175 using bind = Desc<SgSizeOfOp, bool SgSizeOfOp::*, &SgSizeOfOp::p_type_elaboration_required>;
27176};
27177template <> struct describe_field_t<SgSizeOfOp,bool,&SgSizeOfOp::p_global_qualification_required> {
27178 using parent = SgSizeOfOp;
27179 using field_type = bool;
27180 static constexpr size_t position{5};
27181 static constexpr char const * const name{"global_qualification_required"};
27182 static constexpr char const * const typestr{"bool"};
27183 static constexpr bool traverse{false};
27184 static constexpr auto mbr_ptr{&SgSizeOfOp::p_global_qualification_required};
27185 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27186 using bind = Desc<SgSizeOfOp, bool SgSizeOfOp::*, &SgSizeOfOp::p_global_qualification_required>;
27187};
27188template <> struct describe_field_t<SgSizeOfOp,bool,&SgSizeOfOp::p_sizeOfContainsBaseTypeDefiningDeclaration> {
27189 using parent = SgSizeOfOp;
27190 using field_type = bool;
27191 static constexpr size_t position{6};
27192 static constexpr char const * const name{"sizeOfContainsBaseTypeDefiningDeclaration"};
27193 static constexpr char const * const typestr{"bool"};
27194 static constexpr bool traverse{false};
27195 static constexpr auto mbr_ptr{&SgSizeOfOp::p_sizeOfContainsBaseTypeDefiningDeclaration};
27196 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27197 using bind = Desc<SgSizeOfOp, bool SgSizeOfOp::*, &SgSizeOfOp::p_sizeOfContainsBaseTypeDefiningDeclaration>;
27198};
27199template <> struct describe_field_t<SgSizeOfOp,bool,&SgSizeOfOp::p_is_objectless_nonstatic_data_member_reference> {
27200 using parent = SgSizeOfOp;
27201 using field_type = bool;
27202 static constexpr size_t position{7};
27203 static constexpr char const * const name{"is_objectless_nonstatic_data_member_reference"};
27204 static constexpr char const * const typestr{"bool"};
27205 static constexpr bool traverse{false};
27206 static constexpr auto mbr_ptr{&SgSizeOfOp::p_is_objectless_nonstatic_data_member_reference};
27207 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27208 using bind = Desc<SgSizeOfOp, bool SgSizeOfOp::*, &SgSizeOfOp::p_is_objectless_nonstatic_data_member_reference>;
27209};
27210template <> struct describe_field_t<SgSizeOfOp,int,&SgSizeOfOp::p_name_qualification_for_pointer_to_member_class_length> {
27211 using parent = SgSizeOfOp;
27212 using field_type = int;
27213 static constexpr size_t position{8};
27214 static constexpr char const * const name{"name_qualification_for_pointer_to_member_class_length"};
27215 static constexpr char const * const typestr{"int"};
27216 static constexpr bool traverse{false};
27217 static constexpr auto mbr_ptr{&SgSizeOfOp::p_name_qualification_for_pointer_to_member_class_length};
27218 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27219 using bind = Desc<SgSizeOfOp, int SgSizeOfOp::*, &SgSizeOfOp::p_name_qualification_for_pointer_to_member_class_length>;
27220};
27221template <> struct describe_field_t<SgSizeOfOp,bool,&SgSizeOfOp::p_type_elaboration_for_pointer_to_member_class_required> {
27222 using parent = SgSizeOfOp;
27223 using field_type = bool;
27224 static constexpr size_t position{9};
27225 static constexpr char const * const name{"type_elaboration_for_pointer_to_member_class_required"};
27226 static constexpr char const * const typestr{"bool"};
27227 static constexpr bool traverse{false};
27228 static constexpr auto mbr_ptr{&SgSizeOfOp::p_type_elaboration_for_pointer_to_member_class_required};
27229 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27230 using bind = Desc<SgSizeOfOp, bool SgSizeOfOp::*, &SgSizeOfOp::p_type_elaboration_for_pointer_to_member_class_required>;
27231};
27232template <> struct describe_field_t<SgSizeOfOp,bool,&SgSizeOfOp::p_global_qualification_for_pointer_to_member_class_required> {
27233 using parent = SgSizeOfOp;
27234 using field_type = bool;
27235 static constexpr size_t position{10};
27236 static constexpr char const * const name{"global_qualification_for_pointer_to_member_class_required"};
27237 static constexpr char const * const typestr{"bool"};
27238 static constexpr bool traverse{false};
27239 static constexpr auto mbr_ptr{&SgSizeOfOp::p_global_qualification_for_pointer_to_member_class_required};
27240 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27241 using bind = Desc<SgSizeOfOp, bool SgSizeOfOp::*, &SgSizeOfOp::p_global_qualification_for_pointer_to_member_class_required>;
27242};
27252template <> struct node_from_variant_t<685> { using type = SgSizeOfOp; };
27253
27254// Class: AlignOfOp
27255template <> struct describe_field_t<SgAlignOfOp,SgExpression*,&SgAlignOfOp::p_operand_expr> {
27256 using parent = SgAlignOfOp;
27257 using field_type = SgExpression*;
27258 static constexpr size_t position{0};
27259 static constexpr char const * const name{"operand_expr"};
27260 static constexpr char const * const typestr{"SgExpression*"};
27261 static constexpr bool traverse{true};
27262 static constexpr auto mbr_ptr{&SgAlignOfOp::p_operand_expr};
27263 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27264 using bind = Desc<SgAlignOfOp, SgExpression* SgAlignOfOp::*, &SgAlignOfOp::p_operand_expr>;
27265};
27266template <> struct describe_field_t<SgAlignOfOp,SgType*,&SgAlignOfOp::p_operand_type> {
27267 using parent = SgAlignOfOp;
27268 using field_type = SgType*;
27269 static constexpr size_t position{1};
27270 static constexpr char const * const name{"operand_type"};
27271 static constexpr char const * const typestr{"SgType*"};
27272 static constexpr bool traverse{false};
27273 static constexpr auto mbr_ptr{&SgAlignOfOp::p_operand_type};
27274 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27275 using bind = Desc<SgAlignOfOp, SgType* SgAlignOfOp::*, &SgAlignOfOp::p_operand_type>;
27276};
27277template <> struct describe_field_t<SgAlignOfOp,SgType*,&SgAlignOfOp::p_expression_type> {
27278 using parent = SgAlignOfOp;
27279 using field_type = SgType*;
27280 static constexpr size_t position{2};
27281 static constexpr char const * const name{"expression_type"};
27282 static constexpr char const * const typestr{"SgType*"};
27283 static constexpr bool traverse{false};
27284 static constexpr auto mbr_ptr{&SgAlignOfOp::p_expression_type};
27285 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27286 using bind = Desc<SgAlignOfOp, SgType* SgAlignOfOp::*, &SgAlignOfOp::p_expression_type>;
27287};
27288template <> struct describe_field_t<SgAlignOfOp,int,&SgAlignOfOp::p_name_qualification_length> {
27289 using parent = SgAlignOfOp;
27290 using field_type = int;
27291 static constexpr size_t position{3};
27292 static constexpr char const * const name{"name_qualification_length"};
27293 static constexpr char const * const typestr{"int"};
27294 static constexpr bool traverse{false};
27295 static constexpr auto mbr_ptr{&SgAlignOfOp::p_name_qualification_length};
27296 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27297 using bind = Desc<SgAlignOfOp, int SgAlignOfOp::*, &SgAlignOfOp::p_name_qualification_length>;
27298};
27299template <> struct describe_field_t<SgAlignOfOp,bool,&SgAlignOfOp::p_type_elaboration_required> {
27300 using parent = SgAlignOfOp;
27301 using field_type = bool;
27302 static constexpr size_t position{4};
27303 static constexpr char const * const name{"type_elaboration_required"};
27304 static constexpr char const * const typestr{"bool"};
27305 static constexpr bool traverse{false};
27306 static constexpr auto mbr_ptr{&SgAlignOfOp::p_type_elaboration_required};
27307 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27308 using bind = Desc<SgAlignOfOp, bool SgAlignOfOp::*, &SgAlignOfOp::p_type_elaboration_required>;
27309};
27310template <> struct describe_field_t<SgAlignOfOp,bool,&SgAlignOfOp::p_global_qualification_required> {
27311 using parent = SgAlignOfOp;
27312 using field_type = bool;
27313 static constexpr size_t position{5};
27314 static constexpr char const * const name{"global_qualification_required"};
27315 static constexpr char const * const typestr{"bool"};
27316 static constexpr bool traverse{false};
27317 static constexpr auto mbr_ptr{&SgAlignOfOp::p_global_qualification_required};
27318 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27319 using bind = Desc<SgAlignOfOp, bool SgAlignOfOp::*, &SgAlignOfOp::p_global_qualification_required>;
27320};
27321template <> struct describe_field_t<SgAlignOfOp,bool,&SgAlignOfOp::p_alignOfContainsBaseTypeDefiningDeclaration> {
27322 using parent = SgAlignOfOp;
27323 using field_type = bool;
27324 static constexpr size_t position{6};
27325 static constexpr char const * const name{"alignOfContainsBaseTypeDefiningDeclaration"};
27326 static constexpr char const * const typestr{"bool"};
27327 static constexpr bool traverse{false};
27328 static constexpr auto mbr_ptr{&SgAlignOfOp::p_alignOfContainsBaseTypeDefiningDeclaration};
27329 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27330 using bind = Desc<SgAlignOfOp, bool SgAlignOfOp::*, &SgAlignOfOp::p_alignOfContainsBaseTypeDefiningDeclaration>;
27331};
27341template <> struct node_from_variant_t<686> { using type = SgAlignOfOp; };
27342
27343// Class: JavaInstanceOfOp
27344template <> struct describe_field_t<SgJavaInstanceOfOp,SgExpression*,&SgJavaInstanceOfOp::p_operand_expr> {
27345 using parent = SgJavaInstanceOfOp;
27346 using field_type = SgExpression*;
27347 static constexpr size_t position{0};
27348 static constexpr char const * const name{"operand_expr"};
27349 static constexpr char const * const typestr{"SgExpression*"};
27350 static constexpr bool traverse{true};
27351 static constexpr auto mbr_ptr{&SgJavaInstanceOfOp::p_operand_expr};
27352 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27353 using bind = Desc<SgJavaInstanceOfOp, SgExpression* SgJavaInstanceOfOp::*, &SgJavaInstanceOfOp::p_operand_expr>;
27354};
27355template <> struct describe_field_t<SgJavaInstanceOfOp,SgType*,&SgJavaInstanceOfOp::p_operand_type> {
27356 using parent = SgJavaInstanceOfOp;
27357 using field_type = SgType*;
27358 static constexpr size_t position{1};
27359 static constexpr char const * const name{"operand_type"};
27360 static constexpr char const * const typestr{"SgType*"};
27361 static constexpr bool traverse{false};
27362 static constexpr auto mbr_ptr{&SgJavaInstanceOfOp::p_operand_type};
27363 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27364 using bind = Desc<SgJavaInstanceOfOp, SgType* SgJavaInstanceOfOp::*, &SgJavaInstanceOfOp::p_operand_type>;
27365};
27366template <> struct describe_field_t<SgJavaInstanceOfOp,SgType*,&SgJavaInstanceOfOp::p_expression_type> {
27367 using parent = SgJavaInstanceOfOp;
27368 using field_type = SgType*;
27369 static constexpr size_t position{2};
27370 static constexpr char const * const name{"expression_type"};
27371 static constexpr char const * const typestr{"SgType*"};
27372 static constexpr bool traverse{false};
27373 static constexpr auto mbr_ptr{&SgJavaInstanceOfOp::p_expression_type};
27374 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27375 using bind = Desc<SgJavaInstanceOfOp, SgType* SgJavaInstanceOfOp::*, &SgJavaInstanceOfOp::p_expression_type>;
27376};
27378 using node = SgJavaInstanceOfOp;
27379 using base = SgExpression;
27380 static constexpr char const * const name{"JavaInstanceOfOp"};
27381 static constexpr unsigned long variant{687};
27382 static constexpr bool concrete{true};
27383 using subclasses_t = mp::List<>;
27385};
27386template <> struct node_from_variant_t<687> { using type = SgJavaInstanceOfOp; };
27387
27388// Class: SourceFile
27389template <> struct describe_field_t<SgSourceFile,SgGlobal*,&SgSourceFile::p_globalScope> {
27390 using parent = SgSourceFile;
27391 using field_type = SgGlobal*;
27392 static constexpr size_t position{0};
27393 static constexpr char const * const name{"globalScope"};
27394 static constexpr char const * const typestr{"SgGlobal*"};
27395 static constexpr bool traverse{true};
27396 static constexpr auto mbr_ptr{&SgSourceFile::p_globalScope};
27397 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27398 using bind = Desc<SgSourceFile, SgGlobal* SgSourceFile::*, &SgSourceFile::p_globalScope>;
27399};
27400template <> struct describe_field_t<SgSourceFile,SgModuleStatementPtrList,&SgSourceFile::p_module_list> {
27401 using parent = SgSourceFile;
27402 using field_type = SgModuleStatementPtrList;
27403 static constexpr size_t position{1};
27404 static constexpr char const * const name{"module_list"};
27405 static constexpr char const * const typestr{"SgModuleStatementPtrList"};
27406 static constexpr bool traverse{false};
27407 static constexpr auto mbr_ptr{&SgSourceFile::p_module_list};
27408 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27409 using bind = Desc<SgSourceFile, SgModuleStatementPtrList SgSourceFile::*, &SgSourceFile::p_module_list>;
27410};
27411template <> struct describe_field_t<SgSourceFile,SgTokenPtrList,&SgSourceFile::p_token_list> {
27412 using parent = SgSourceFile;
27413 using field_type = SgTokenPtrList;
27414 static constexpr size_t position{2};
27415 static constexpr char const * const name{"token_list"};
27416 static constexpr char const * const typestr{"SgTokenPtrList"};
27417 static constexpr bool traverse{false};
27418 static constexpr auto mbr_ptr{&SgSourceFile::p_token_list};
27419 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27420 using bind = Desc<SgSourceFile, SgTokenPtrList SgSourceFile::*, &SgSourceFile::p_token_list>;
27421};
27422template <> struct describe_field_t<SgSourceFile,SgGlobal*,&SgSourceFile::p_temp_holding_scope> {
27423 using parent = SgSourceFile;
27424 using field_type = SgGlobal*;
27425 static constexpr size_t position{3};
27426 static constexpr char const * const name{"temp_holding_scope"};
27427 static constexpr char const * const typestr{"SgGlobal*"};
27428 static constexpr bool traverse{false};
27429 static constexpr auto mbr_ptr{&SgSourceFile::p_temp_holding_scope};
27430 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27431 using bind = Desc<SgSourceFile, SgGlobal* SgSourceFile::*, &SgSourceFile::p_temp_holding_scope>;
27432};
27433template <> struct describe_field_t<SgSourceFile,SgJavaPackageStatement *,&SgSourceFile::p_package> {
27434 using parent = SgSourceFile;
27436 static constexpr size_t position{4};
27437 static constexpr char const * const name{"package"};
27438 static constexpr char const * const typestr{"SgJavaPackageStatement *"};
27439 static constexpr bool traverse{true};
27440 static constexpr auto mbr_ptr{&SgSourceFile::p_package};
27441 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27442 using bind = Desc<SgSourceFile, SgJavaPackageStatement * SgSourceFile::*, &SgSourceFile::p_package>;
27443};
27444template <> struct describe_field_t<SgSourceFile,SgJavaImportStatementList*,&SgSourceFile::p_import_list> {
27445 using parent = SgSourceFile;
27447 static constexpr size_t position{5};
27448 static constexpr char const * const name{"import_list"};
27449 static constexpr char const * const typestr{"SgJavaImportStatementList*"};
27450 static constexpr bool traverse{true};
27451 static constexpr auto mbr_ptr{&SgSourceFile::p_import_list};
27452 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27453 using bind = Desc<SgSourceFile, SgJavaImportStatementList* SgSourceFile::*, &SgSourceFile::p_import_list>;
27454};
27455template <> struct describe_field_t<SgSourceFile,SgJavaClassDeclarationList*,&SgSourceFile::p_class_list> {
27456 using parent = SgSourceFile;
27458 static constexpr size_t position{6};
27459 static constexpr char const * const name{"class_list"};
27460 static constexpr char const * const typestr{"SgJavaClassDeclarationList*"};
27461 static constexpr bool traverse{true};
27462 static constexpr auto mbr_ptr{&SgSourceFile::p_class_list};
27463 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27464 using bind = Desc<SgSourceFile, SgJavaClassDeclarationList* SgSourceFile::*, &SgSourceFile::p_class_list>;
27465};
27466template <> struct describe_field_t<SgSourceFile,bool,&SgSourceFile::p_isHeaderFile> {
27467 using parent = SgSourceFile;
27468 using field_type = bool;
27469 static constexpr size_t position{7};
27470 static constexpr char const * const name{"isHeaderFile"};
27471 static constexpr char const * const typestr{"bool"};
27472 static constexpr bool traverse{false};
27473 static constexpr auto mbr_ptr{&SgSourceFile::p_isHeaderFile};
27474 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27475 using bind = Desc<SgSourceFile, bool SgSourceFile::*, &SgSourceFile::p_isHeaderFile>;
27476};
27477template <> struct describe_field_t<SgSourceFile,bool,&SgSourceFile::p_isHeaderFileIncludedMoreThanOnce> {
27478 using parent = SgSourceFile;
27479 using field_type = bool;
27480 static constexpr size_t position{8};
27481 static constexpr char const * const name{"isHeaderFileIncludedMoreThanOnce"};
27482 static constexpr char const * const typestr{"bool"};
27483 static constexpr bool traverse{false};
27484 static constexpr auto mbr_ptr{&SgSourceFile::p_isHeaderFileIncludedMoreThanOnce};
27485 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27486 using bind = Desc<SgSourceFile, bool SgSourceFile::*, &SgSourceFile::p_isHeaderFileIncludedMoreThanOnce>;
27487};
27488template <> struct describe_field_t<SgSourceFile,SgHeaderFileReport*,&SgSourceFile::p_headerFileReport> {
27489 using parent = SgSourceFile;
27491 static constexpr size_t position{9};
27492 static constexpr char const * const name{"headerFileReport"};
27493 static constexpr char const * const typestr{"SgHeaderFileReport*"};
27494 static constexpr bool traverse{false};
27495 static constexpr auto mbr_ptr{&SgSourceFile::p_headerFileReport};
27496 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27497 using bind = Desc<SgSourceFile, SgHeaderFileReport* SgSourceFile::*, &SgSourceFile::p_headerFileReport>;
27498};
27499template <> struct describe_field_t<SgSourceFile,SgStringList,&SgSourceFile::p_extraIncludeDirectorySpecifierBeforeList> {
27500 using parent = SgSourceFile;
27501 using field_type = SgStringList;
27502 static constexpr size_t position{10};
27503 static constexpr char const * const name{"extraIncludeDirectorySpecifierBeforeList"};
27504 static constexpr char const * const typestr{"SgStringList"};
27505 static constexpr bool traverse{false};
27506 static constexpr auto mbr_ptr{&SgSourceFile::p_extraIncludeDirectorySpecifierBeforeList};
27507 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27508 using bind = Desc<SgSourceFile, SgStringList SgSourceFile::*, &SgSourceFile::p_extraIncludeDirectorySpecifierBeforeList>;
27509};
27510template <> struct describe_field_t<SgSourceFile,SgStringList,&SgSourceFile::p_extraIncludeDirectorySpecifierAfterList> {
27511 using parent = SgSourceFile;
27512 using field_type = SgStringList;
27513 static constexpr size_t position{11};
27514 static constexpr char const * const name{"extraIncludeDirectorySpecifierAfterList"};
27515 static constexpr char const * const typestr{"SgStringList"};
27516 static constexpr bool traverse{false};
27517 static constexpr auto mbr_ptr{&SgSourceFile::p_extraIncludeDirectorySpecifierAfterList};
27518 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27519 using bind = Desc<SgSourceFile, SgStringList SgSourceFile::*, &SgSourceFile::p_extraIncludeDirectorySpecifierAfterList>;
27520};
27521template <> struct describe_field_t<SgSourceFile,SgIncludeFile*,&SgSourceFile::p_associated_include_file> {
27522 using parent = SgSourceFile;
27523 using field_type = SgIncludeFile*;
27524 static constexpr size_t position{12};
27525 static constexpr char const * const name{"associated_include_file"};
27526 static constexpr char const * const typestr{"SgIncludeFile*"};
27527 static constexpr bool traverse{false};
27528 static constexpr auto mbr_ptr{&SgSourceFile::p_associated_include_file};
27529 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27530 using bind = Desc<SgSourceFile, SgIncludeFile* SgSourceFile::*, &SgSourceFile::p_associated_include_file>;
27531};
27532template <> struct describe_field_t<SgSourceFile,bool,&SgSourceFile::p_processedToIncludeCppDirectivesAndComments> {
27533 using parent = SgSourceFile;
27534 using field_type = bool;
27535 static constexpr size_t position{13};
27536 static constexpr char const * const name{"processedToIncludeCppDirectivesAndComments"};
27537 static constexpr char const * const typestr{"bool"};
27538 static constexpr bool traverse{false};
27539 static constexpr auto mbr_ptr{&SgSourceFile::p_processedToIncludeCppDirectivesAndComments};
27540 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27541 using bind = Desc<SgSourceFile, bool SgSourceFile::*, &SgSourceFile::p_processedToIncludeCppDirectivesAndComments>;
27542};
27543template <> struct describe_field_t<SgSourceFile,SgNodePtrList,&SgSourceFile::p_extra_nodes_for_namequal_init> {
27544 using parent = SgSourceFile;
27545 using field_type = SgNodePtrList;
27546 static constexpr size_t position{14};
27547 static constexpr char const * const name{"extra_nodes_for_namequal_init"};
27548 static constexpr char const * const typestr{"SgNodePtrList"};
27549 static constexpr bool traverse{false};
27550 static constexpr auto mbr_ptr{&SgSourceFile::p_extra_nodes_for_namequal_init};
27551 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27552 using bind = Desc<SgSourceFile, SgNodePtrList SgSourceFile::*, &SgSourceFile::p_extra_nodes_for_namequal_init>;
27553};
27554template <> struct describe_field_t<SgSourceFile,bool,&SgSourceFile::p_isDynamicLibrary> {
27555 using parent = SgSourceFile;
27556 using field_type = bool;
27557 static constexpr size_t position{15};
27558 static constexpr char const * const name{"isDynamicLibrary"};
27559 static constexpr char const * const typestr{"bool"};
27560 static constexpr bool traverse{false};
27561 static constexpr auto mbr_ptr{&SgSourceFile::p_isDynamicLibrary};
27562 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27563 using bind = Desc<SgSourceFile, bool SgSourceFile::*, &SgSourceFile::p_isDynamicLibrary>;
27564};
27565template <> struct describe_field_t<SgSourceFile,SgStatement*,&SgSourceFile::p_firstStatement> {
27566 using parent = SgSourceFile;
27567 using field_type = SgStatement*;
27568 static constexpr size_t position{16};
27569 static constexpr char const * const name{"firstStatement"};
27570 static constexpr char const * const typestr{"SgStatement*"};
27571 static constexpr bool traverse{false};
27572 static constexpr auto mbr_ptr{&SgSourceFile::p_firstStatement};
27573 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27574 using bind = Desc<SgSourceFile, SgStatement* SgSourceFile::*, &SgSourceFile::p_firstStatement>;
27575};
27576template <> struct describe_field_t<SgSourceFile,SgStatement*,&SgSourceFile::p_lastStatement> {
27577 using parent = SgSourceFile;
27578 using field_type = SgStatement*;
27579 static constexpr size_t position{17};
27580 static constexpr char const * const name{"lastStatement"};
27581 static constexpr char const * const typestr{"SgStatement*"};
27582 static constexpr bool traverse{false};
27583 static constexpr auto mbr_ptr{&SgSourceFile::p_lastStatement};
27584 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27585 using bind = Desc<SgSourceFile, SgStatement* SgSourceFile::*, &SgSourceFile::p_lastStatement>;
27586};
27587template <> struct describe_node_t<SgSourceFile> {
27588 using node = SgSourceFile;
27589 using base = SgFile;
27590 static constexpr char const * const name{"SourceFile"};
27591 static constexpr unsigned long variant{688};
27592 static constexpr bool concrete{true};
27593 using subclasses_t = mp::List<>;
27594 using fields_t = mp::List<describe_field_t<SgSourceFile,SgGlobal*,&SgSourceFile::p_globalScope>, describe_field_t<SgSourceFile,SgModuleStatementPtrList,&SgSourceFile::p_module_list>, describe_field_t<SgSourceFile,SgTokenPtrList,&SgSourceFile::p_token_list>, describe_field_t<SgSourceFile,SgGlobal*,&SgSourceFile::p_temp_holding_scope>, describe_field_t<SgSourceFile,SgJavaPackageStatement *,&SgSourceFile::p_package>, describe_field_t<SgSourceFile,SgJavaImportStatementList*,&SgSourceFile::p_import_list>, describe_field_t<SgSourceFile,SgJavaClassDeclarationList*,&SgSourceFile::p_class_list>, describe_field_t<SgSourceFile,bool,&SgSourceFile::p_isHeaderFile>, describe_field_t<SgSourceFile,bool,&SgSourceFile::p_isHeaderFileIncludedMoreThanOnce>, describe_field_t<SgSourceFile,SgHeaderFileReport*,&SgSourceFile::p_headerFileReport>, describe_field_t<SgSourceFile,SgStringList,&SgSourceFile::p_extraIncludeDirectorySpecifierBeforeList>, describe_field_t<SgSourceFile,SgStringList,&SgSourceFile::p_extraIncludeDirectorySpecifierAfterList>, describe_field_t<SgSourceFile,SgIncludeFile*,&SgSourceFile::p_associated_include_file>, describe_field_t<SgSourceFile,bool,&SgSourceFile::p_processedToIncludeCppDirectivesAndComments>, describe_field_t<SgSourceFile,SgNodePtrList,&SgSourceFile::p_extra_nodes_for_namequal_init>, describe_field_t<SgSourceFile,bool,&SgSourceFile::p_isDynamicLibrary>, describe_field_t<SgSourceFile,SgStatement*,&SgSourceFile::p_firstStatement>, describe_field_t<SgSourceFile,SgStatement*,&SgSourceFile::p_lastStatement>>;
27595};
27596template <> struct node_from_variant_t<688> { using type = SgSourceFile; };
27597
27598// Class: SpaceshipOp
27599template <> struct describe_node_t<SgSpaceshipOp> {
27600 using node = SgSpaceshipOp;
27601 using base = SgBinaryOp;
27602 static constexpr char const * const name{"SpaceshipOp"};
27603 static constexpr unsigned long variant{689};
27604 static constexpr bool concrete{true};
27605 using subclasses_t = mp::List<>;
27606 using fields_t = mp::List<>;
27607};
27608template <> struct node_from_variant_t<689> { using type = SgSpaceshipOp; };
27609
27610// Class: SpawnStmt
27611template <> struct describe_field_t<SgSpawnStmt,SgFunctionCallExp*,&SgSpawnStmt::p_the_func> {
27612 using parent = SgSpawnStmt;
27614 static constexpr size_t position{0};
27615 static constexpr char const * const name{"the_func"};
27616 static constexpr char const * const typestr{"SgFunctionCallExp*"};
27617 static constexpr bool traverse{true};
27618 static constexpr auto mbr_ptr{&SgSpawnStmt::p_the_func};
27619 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27620 using bind = Desc<SgSpawnStmt, SgFunctionCallExp* SgSpawnStmt::*, &SgSpawnStmt::p_the_func>;
27621};
27622template <> struct describe_node_t<SgSpawnStmt> {
27623 using node = SgSpawnStmt;
27624 using base = SgStatement;
27625 static constexpr char const * const name{"SpawnStmt"};
27626 static constexpr unsigned long variant{690};
27627 static constexpr bool concrete{true};
27628 using subclasses_t = mp::List<>;
27630};
27631template <> struct node_from_variant_t<690> { using type = SgSpawnStmt; };
27632
27633// Class: SyncAllStatement
27635 using node = SgSyncAllStatement;
27637 static constexpr char const * const name{"SyncAllStatement"};
27638 static constexpr unsigned long variant{691};
27639 static constexpr bool concrete{true};
27640 using subclasses_t = mp::List<>;
27641 using fields_t = mp::List<>;
27642};
27643template <> struct node_from_variant_t<691> { using type = SgSyncAllStatement; };
27644
27645// Class: SyncImagesStatement
27646template <> struct describe_field_t<SgSyncImagesStatement,SgExpression*,&SgSyncImagesStatement::p_image_set> {
27648 using field_type = SgExpression*;
27649 static constexpr size_t position{0};
27650 static constexpr char const * const name{"image_set"};
27651 static constexpr char const * const typestr{"SgExpression*"};
27652 static constexpr bool traverse{true};
27653 static constexpr auto mbr_ptr{&SgSyncImagesStatement::p_image_set};
27654 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27655 using bind = Desc<SgSyncImagesStatement, SgExpression* SgSyncImagesStatement::*, &SgSyncImagesStatement::p_image_set>;
27656};
27660 static constexpr char const * const name{"SyncImagesStatement"};
27661 static constexpr unsigned long variant{692};
27662 static constexpr bool concrete{true};
27663 using subclasses_t = mp::List<>;
27665};
27666template <> struct node_from_variant_t<692> { using type = SgSyncImagesStatement; };
27667
27668// Class: SyncMemoryStatement
27672 static constexpr char const * const name{"SyncMemoryStatement"};
27673 static constexpr unsigned long variant{693};
27674 static constexpr bool concrete{true};
27675 using subclasses_t = mp::List<>;
27676 using fields_t = mp::List<>;
27677};
27678template <> struct node_from_variant_t<693> { using type = SgSyncMemoryStatement; };
27679
27680// Class: SyncTeamStatement
27681template <> struct describe_field_t<SgSyncTeamStatement,SgExpression*,&SgSyncTeamStatement::p_team_value> {
27683 using field_type = SgExpression*;
27684 static constexpr size_t position{0};
27685 static constexpr char const * const name{"team_value"};
27686 static constexpr char const * const typestr{"SgExpression*"};
27687 static constexpr bool traverse{true};
27688 static constexpr auto mbr_ptr{&SgSyncTeamStatement::p_team_value};
27689 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27690 using bind = Desc<SgSyncTeamStatement, SgExpression* SgSyncTeamStatement::*, &SgSyncTeamStatement::p_team_value>;
27691};
27693 using node = SgSyncTeamStatement;
27695 static constexpr char const * const name{"SyncTeamStatement"};
27696 static constexpr unsigned long variant{694};
27697 static constexpr bool concrete{true};
27698 using subclasses_t = mp::List<>;
27700};
27701template <> struct node_from_variant_t<694> { using type = SgSyncTeamStatement; };
27702
27703// Class: LockStatement
27704template <> struct describe_field_t<SgLockStatement,SgExpression*,&SgLockStatement::p_lock_variable> {
27705 using parent = SgLockStatement;
27706 using field_type = SgExpression*;
27707 static constexpr size_t position{0};
27708 static constexpr char const * const name{"lock_variable"};
27709 static constexpr char const * const typestr{"SgExpression*"};
27710 static constexpr bool traverse{true};
27711 static constexpr auto mbr_ptr{&SgLockStatement::p_lock_variable};
27712 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27713 using bind = Desc<SgLockStatement, SgExpression* SgLockStatement::*, &SgLockStatement::p_lock_variable>;
27714};
27716 using node = SgLockStatement;
27718 static constexpr char const * const name{"LockStatement"};
27719 static constexpr unsigned long variant{695};
27720 static constexpr bool concrete{true};
27721 using subclasses_t = mp::List<>;
27723};
27724template <> struct node_from_variant_t<695> { using type = SgLockStatement; };
27725
27726// Class: UnlockStatement
27727template <> struct describe_field_t<SgUnlockStatement,SgExpression*,&SgUnlockStatement::p_lock_variable> {
27728 using parent = SgUnlockStatement;
27729 using field_type = SgExpression*;
27730 static constexpr size_t position{0};
27731 static constexpr char const * const name{"lock_variable"};
27732 static constexpr char const * const typestr{"SgExpression*"};
27733 static constexpr bool traverse{true};
27734 static constexpr auto mbr_ptr{&SgUnlockStatement::p_lock_variable};
27735 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27736 using bind = Desc<SgUnlockStatement, SgExpression* SgUnlockStatement::*, &SgUnlockStatement::p_lock_variable>;
27737};
27739 using node = SgUnlockStatement;
27741 static constexpr char const * const name{"UnlockStatement"};
27742 static constexpr unsigned long variant{696};
27743 static constexpr bool concrete{true};
27744 using subclasses_t = mp::List<>;
27746};
27747template <> struct node_from_variant_t<696> { using type = SgUnlockStatement; };
27748
27749// Class: JavaThrowStatement
27750template <> struct describe_field_t<SgJavaThrowStatement,SgThrowOp*,&SgJavaThrowStatement::p_throwOp> {
27752 using field_type = SgThrowOp*;
27753 static constexpr size_t position{0};
27754 static constexpr char const * const name{"throwOp"};
27755 static constexpr char const * const typestr{"SgThrowOp*"};
27756 static constexpr bool traverse{false};
27757 static constexpr auto mbr_ptr{&SgJavaThrowStatement::p_throwOp};
27758 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27759 using bind = Desc<SgJavaThrowStatement, SgThrowOp* SgJavaThrowStatement::*, &SgJavaThrowStatement::p_throwOp>;
27760};
27762 using node = SgJavaThrowStatement;
27763 using base = SgStatement;
27764 static constexpr char const * const name{"JavaThrowStatement"};
27765 static constexpr unsigned long variant{697};
27766 static constexpr bool concrete{true};
27767 using subclasses_t = mp::List<>;
27769};
27770template <> struct node_from_variant_t<697> { using type = SgJavaThrowStatement; };
27771
27772// Class: JavaForEachStatement
27773template <> struct describe_field_t<SgJavaForEachStatement,SgVariableDeclaration*,&SgJavaForEachStatement::p_element> {
27776 static constexpr size_t position{0};
27777 static constexpr char const * const name{"element"};
27778 static constexpr char const * const typestr{"SgVariableDeclaration*"};
27779 static constexpr bool traverse{true};
27780 static constexpr auto mbr_ptr{&SgJavaForEachStatement::p_element};
27781 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27782 using bind = Desc<SgJavaForEachStatement, SgVariableDeclaration* SgJavaForEachStatement::*, &SgJavaForEachStatement::p_element>;
27783};
27784template <> struct describe_field_t<SgJavaForEachStatement,SgExpression*,&SgJavaForEachStatement::p_collection> {
27786 using field_type = SgExpression*;
27787 static constexpr size_t position{1};
27788 static constexpr char const * const name{"collection"};
27789 static constexpr char const * const typestr{"SgExpression*"};
27790 static constexpr bool traverse{true};
27791 static constexpr auto mbr_ptr{&SgJavaForEachStatement::p_collection};
27792 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27793 using bind = Desc<SgJavaForEachStatement, SgExpression* SgJavaForEachStatement::*, &SgJavaForEachStatement::p_collection>;
27794};
27795template <> struct describe_field_t<SgJavaForEachStatement,SgStatement*,&SgJavaForEachStatement::p_loop_body> {
27797 using field_type = SgStatement*;
27798 static constexpr size_t position{2};
27799 static constexpr char const * const name{"loop_body"};
27800 static constexpr char const * const typestr{"SgStatement*"};
27801 static constexpr bool traverse{true};
27802 static constexpr auto mbr_ptr{&SgJavaForEachStatement::p_loop_body};
27803 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27804 using bind = Desc<SgJavaForEachStatement, SgStatement* SgJavaForEachStatement::*, &SgJavaForEachStatement::p_loop_body>;
27805};
27808 using base = SgScopeStatement;
27809 static constexpr char const * const name{"JavaForEachStatement"};
27810 static constexpr unsigned long variant{698};
27811 static constexpr bool concrete{true};
27812 using subclasses_t = mp::List<>;
27814};
27815template <> struct node_from_variant_t<698> { using type = SgJavaForEachStatement; };
27816
27817// Class: JavaSynchronizedStatement
27818template <> struct describe_field_t<SgJavaSynchronizedStatement,SgExpression*,&SgJavaSynchronizedStatement::p_expression> {
27820 using field_type = SgExpression*;
27821 static constexpr size_t position{0};
27822 static constexpr char const * const name{"expression"};
27823 static constexpr char const * const typestr{"SgExpression*"};
27824 static constexpr bool traverse{true};
27825 static constexpr auto mbr_ptr{&SgJavaSynchronizedStatement::p_expression};
27826 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27827 using bind = Desc<SgJavaSynchronizedStatement, SgExpression* SgJavaSynchronizedStatement::*, &SgJavaSynchronizedStatement::p_expression>;
27828};
27829template <> struct describe_field_t<SgJavaSynchronizedStatement,SgStatement*,&SgJavaSynchronizedStatement::p_body> {
27831 using field_type = SgStatement*;
27832 static constexpr size_t position{1};
27833 static constexpr char const * const name{"body"};
27834 static constexpr char const * const typestr{"SgStatement*"};
27835 static constexpr bool traverse{true};
27836 static constexpr auto mbr_ptr{&SgJavaSynchronizedStatement::p_body};
27837 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27838 using bind = Desc<SgJavaSynchronizedStatement, SgStatement* SgJavaSynchronizedStatement::*, &SgJavaSynchronizedStatement::p_body>;
27839};
27842 using base = SgStatement;
27843 static constexpr char const * const name{"JavaSynchronizedStatement"};
27844 static constexpr unsigned long variant{699};
27845 static constexpr bool concrete{true};
27846 using subclasses_t = mp::List<>;
27848};
27849template <> struct node_from_variant_t<699> { using type = SgJavaSynchronizedStatement; };
27850
27851// Class: JavaParameterizedType
27852template <> struct describe_field_t<SgJavaParameterizedType,SgNamedType*,&SgJavaParameterizedType::p_raw_type> {
27854 using field_type = SgNamedType*;
27855 static constexpr size_t position{0};
27856 static constexpr char const * const name{"raw_type"};
27857 static constexpr char const * const typestr{"SgNamedType*"};
27858 static constexpr bool traverse{false};
27859 static constexpr auto mbr_ptr{&SgJavaParameterizedType::p_raw_type};
27860 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27861 using bind = Desc<SgJavaParameterizedType, SgNamedType* SgJavaParameterizedType::*, &SgJavaParameterizedType::p_raw_type>;
27862};
27863template <> struct describe_field_t<SgJavaParameterizedType,SgTemplateParameterList*,&SgJavaParameterizedType::p_type_list> {
27866 static constexpr size_t position{1};
27867 static constexpr char const * const name{"type_list"};
27868 static constexpr char const * const typestr{"SgTemplateParameterList*"};
27869 static constexpr bool traverse{false};
27870 static constexpr auto mbr_ptr{&SgJavaParameterizedType::p_type_list};
27871 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27872 using bind = Desc<SgJavaParameterizedType, SgTemplateParameterList* SgJavaParameterizedType::*, &SgJavaParameterizedType::p_type_list>;
27873};
27876 using base = SgNamedType;
27877 static constexpr char const * const name{"JavaParameterizedType"};
27878 static constexpr unsigned long variant{700};
27879 static constexpr bool concrete{true};
27880 using subclasses_t = mp::List<>;
27882};
27883template <> struct node_from_variant_t<700> { using type = SgJavaParameterizedType; };
27884
27885// Class: JavaWildcardType
27886template <> struct describe_field_t<SgJavaWildcardType,SgType*,&SgJavaWildcardType::p_bound_type> {
27887 using parent = SgJavaWildcardType;
27888 using field_type = SgType*;
27889 static constexpr size_t position{0};
27890 static constexpr char const * const name{"bound_type"};
27891 static constexpr char const * const typestr{"SgType*"};
27892 static constexpr bool traverse{false};
27893 static constexpr auto mbr_ptr{&SgJavaWildcardType::p_bound_type};
27894 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27895 using bind = Desc<SgJavaWildcardType, SgType* SgJavaWildcardType::*, &SgJavaWildcardType::p_bound_type>;
27896};
27897template <> struct describe_field_t<SgJavaWildcardType,bool,&SgJavaWildcardType::p_is_unbound> {
27898 using parent = SgJavaWildcardType;
27899 using field_type = bool;
27900 static constexpr size_t position{1};
27901 static constexpr char const * const name{"is_unbound"};
27902 static constexpr char const * const typestr{"bool"};
27903 static constexpr bool traverse{false};
27904 static constexpr auto mbr_ptr{&SgJavaWildcardType::p_is_unbound};
27905 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27906 using bind = Desc<SgJavaWildcardType, bool SgJavaWildcardType::*, &SgJavaWildcardType::p_is_unbound>;
27907};
27908template <> struct describe_field_t<SgJavaWildcardType,bool,&SgJavaWildcardType::p_has_extends> {
27909 using parent = SgJavaWildcardType;
27910 using field_type = bool;
27911 static constexpr size_t position{2};
27912 static constexpr char const * const name{"has_extends"};
27913 static constexpr char const * const typestr{"bool"};
27914 static constexpr bool traverse{false};
27915 static constexpr auto mbr_ptr{&SgJavaWildcardType::p_has_extends};
27916 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27917 using bind = Desc<SgJavaWildcardType, bool SgJavaWildcardType::*, &SgJavaWildcardType::p_has_extends>;
27918};
27919template <> struct describe_field_t<SgJavaWildcardType,bool,&SgJavaWildcardType::p_has_super> {
27920 using parent = SgJavaWildcardType;
27921 using field_type = bool;
27922 static constexpr size_t position{3};
27923 static constexpr char const * const name{"has_super"};
27924 static constexpr char const * const typestr{"bool"};
27925 static constexpr bool traverse{false};
27926 static constexpr auto mbr_ptr{&SgJavaWildcardType::p_has_super};
27927 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27928 using bind = Desc<SgJavaWildcardType, bool SgJavaWildcardType::*, &SgJavaWildcardType::p_has_super>;
27929};
27939template <> struct node_from_variant_t<701> { using type = SgJavaWildcardType; };
27940
27941// Class: ProcessControlStatement
27942template <> struct describe_field_t<SgProcessControlStatement,SgProcessControlStatement::control_enum,&SgProcessControlStatement::p_control_kind> {
27944 using field_type = SgProcessControlStatement::control_enum;
27945 static constexpr size_t position{0};
27946 static constexpr char const * const name{"control_kind"};
27947 static constexpr char const * const typestr{"SgProcessControlStatement::control_enum"};
27948 static constexpr bool traverse{false};
27949 static constexpr auto mbr_ptr{&SgProcessControlStatement::p_control_kind};
27950 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27951 using bind = Desc<SgProcessControlStatement, SgProcessControlStatement::control_enum SgProcessControlStatement::*, &SgProcessControlStatement::p_control_kind>;
27952};
27953template <> struct describe_field_t<SgProcessControlStatement,SgExpression*,&SgProcessControlStatement::p_code> {
27955 using field_type = SgExpression*;
27956 static constexpr size_t position{1};
27957 static constexpr char const * const name{"code"};
27958 static constexpr char const * const typestr{"SgExpression*"};
27959 static constexpr bool traverse{true};
27960 static constexpr auto mbr_ptr{&SgProcessControlStatement::p_code};
27961 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27962 using bind = Desc<SgProcessControlStatement, SgExpression* SgProcessControlStatement::*, &SgProcessControlStatement::p_code>;
27963};
27964template <> struct describe_field_t<SgProcessControlStatement,SgExpression*,&SgProcessControlStatement::p_quiet> {
27966 using field_type = SgExpression*;
27967 static constexpr size_t position{2};
27968 static constexpr char const * const name{"quiet"};
27969 static constexpr char const * const typestr{"SgExpression*"};
27970 static constexpr bool traverse{true};
27971 static constexpr auto mbr_ptr{&SgProcessControlStatement::p_quiet};
27972 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27973 using bind = Desc<SgProcessControlStatement, SgExpression* SgProcessControlStatement::*, &SgProcessControlStatement::p_quiet>;
27974};
27984template <> struct node_from_variant_t<702> { using type = SgProcessControlStatement; };
27985
27986// Class: SpecialFunctionModifier
27987template <> struct describe_field_t<SgSpecialFunctionModifier,SgBitVector,&SgSpecialFunctionModifier::p_modifierVector> {
27989 using field_type = SgBitVector;
27990 static constexpr size_t position{0};
27991 static constexpr char const * const name{"modifierVector"};
27992 static constexpr char const * const typestr{"SgBitVector"};
27993 static constexpr bool traverse{false};
27994 static constexpr auto mbr_ptr{&SgSpecialFunctionModifier::p_modifierVector};
27995 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
27996 using bind = Desc<SgSpecialFunctionModifier, SgBitVector SgSpecialFunctionModifier::*, &SgSpecialFunctionModifier::p_modifierVector>;
27997};
28000 using base = SgModifier;
28001 static constexpr char const * const name{"SpecialFunctionModifier"};
28002 static constexpr unsigned long variant{703};
28003 static constexpr bool concrete{true};
28004 using subclasses_t = mp::List<>;
28006};
28007template <> struct node_from_variant_t<703> { using type = SgSpecialFunctionModifier; };
28008
28009// Class: Statement
28010template <> struct describe_field_t<SgStatement,SgLabelRefExp*,&SgStatement::p_numeric_label> {
28011 using parent = SgStatement;
28012 using field_type = SgLabelRefExp*;
28013 static constexpr size_t position{0};
28014 static constexpr char const * const name{"numeric_label"};
28015 static constexpr char const * const typestr{"SgLabelRefExp*"};
28016 static constexpr bool traverse{false};
28017 static constexpr auto mbr_ptr{&SgStatement::p_numeric_label};
28018 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28019 using bind = Desc<SgStatement, SgLabelRefExp* SgStatement::*, &SgStatement::p_numeric_label>;
28020};
28021template <> struct describe_field_t<SgStatement,int,&SgStatement::p_source_sequence_value> {
28022 using parent = SgStatement;
28023 using field_type = int;
28024 static constexpr size_t position{1};
28025 static constexpr char const * const name{"source_sequence_value"};
28026 static constexpr char const * const typestr{"int"};
28027 static constexpr bool traverse{false};
28028 static constexpr auto mbr_ptr{&SgStatement::p_source_sequence_value};
28029 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28030 using bind = Desc<SgStatement, int SgStatement::*, &SgStatement::p_source_sequence_value>;
28031};
28032template <> struct describe_node_t<SgStatement> {
28033 using node = SgStatement;
28034 using base = SgLocatedNode;
28035 static constexpr char const * const name{"Statement"};
28036 static constexpr unsigned long variant{704};
28037 static constexpr bool concrete{false};
28040};
28041template <> struct node_from_variant_t<704> { using type = SgStatement; };
28042
28043// Class: StaticAssertionDeclaration
28044template <> struct describe_field_t<SgStaticAssertionDeclaration,SgExpression*,&SgStaticAssertionDeclaration::p_condition> {
28046 using field_type = SgExpression*;
28047 static constexpr size_t position{0};
28048 static constexpr char const * const name{"condition"};
28049 static constexpr char const * const typestr{"SgExpression*"};
28050 static constexpr bool traverse{true};
28051 static constexpr auto mbr_ptr{&SgStaticAssertionDeclaration::p_condition};
28052 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28053 using bind = Desc<SgStaticAssertionDeclaration, SgExpression* SgStaticAssertionDeclaration::*, &SgStaticAssertionDeclaration::p_condition>;
28054};
28055template <> struct describe_field_t<SgStaticAssertionDeclaration,SgName,&SgStaticAssertionDeclaration::p_string_literal> {
28057 using field_type = SgName;
28058 static constexpr size_t position{1};
28059 static constexpr char const * const name{"string_literal"};
28060 static constexpr char const * const typestr{"SgName"};
28061 static constexpr bool traverse{false};
28062 static constexpr auto mbr_ptr{&SgStaticAssertionDeclaration::p_string_literal};
28063 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28064 using bind = Desc<SgStaticAssertionDeclaration, SgName SgStaticAssertionDeclaration::*, &SgStaticAssertionDeclaration::p_string_literal>;
28065};
28069 static constexpr char const * const name{"StaticAssertionDeclaration"};
28070 static constexpr unsigned long variant{705};
28071 static constexpr bool concrete{true};
28072 using subclasses_t = mp::List<>;
28074};
28075template <> struct node_from_variant_t<705> { using type = SgStaticAssertionDeclaration; };
28076
28077// Class: StmtDeclarationStatement
28080 using field_type = SgStatement*;
28081 static constexpr size_t position{0};
28082 static constexpr char const * const name{"statement"};
28083 static constexpr char const * const typestr{"SgStatement*"};
28084 static constexpr bool traverse{true};
28085 static constexpr auto mbr_ptr{&SgStmtDeclarationStatement::p_statement};
28086 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28087 using bind = Desc<SgStmtDeclarationStatement, SgStatement* SgStmtDeclarationStatement::*, &SgStmtDeclarationStatement::p_statement>;
28088};
28092 static constexpr char const * const name{"StmtDeclarationStatement"};
28093 static constexpr unsigned long variant{706};
28094 static constexpr bool concrete{true};
28095 using subclasses_t = mp::List<>;
28097};
28098template <> struct node_from_variant_t<706> { using type = SgStmtDeclarationStatement; };
28099
28100// Class: StatementExpression
28103 using field_type = SgStatement*;
28104 static constexpr size_t position{0};
28105 static constexpr char const * const name{"statement"};
28106 static constexpr char const * const typestr{"SgStatement*"};
28107 static constexpr bool traverse{true};
28108 static constexpr auto mbr_ptr{&SgStatementExpression::p_statement};
28109 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28110 using bind = Desc<SgStatementExpression, SgStatement* SgStatementExpression::*, &SgStatementExpression::p_statement>;
28111};
28114 using base = SgExpression;
28115 static constexpr char const * const name{"StatementExpression"};
28116 static constexpr unsigned long variant{707};
28117 static constexpr bool concrete{true};
28118 using subclasses_t = mp::List<>;
28120};
28121template <> struct node_from_variant_t<707> { using type = SgStatementExpression; };
28122
28123// Class: StatementFunctionStatement
28124template <> struct describe_field_t<SgStatementFunctionStatement,SgFunctionDeclaration*,&SgStatementFunctionStatement::p_function> {
28127 static constexpr size_t position{0};
28128 static constexpr char const * const name{"function"};
28129 static constexpr char const * const typestr{"SgFunctionDeclaration*"};
28130 static constexpr bool traverse{true};
28131 static constexpr auto mbr_ptr{&SgStatementFunctionStatement::p_function};
28132 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28133 using bind = Desc<SgStatementFunctionStatement, SgFunctionDeclaration* SgStatementFunctionStatement::*, &SgStatementFunctionStatement::p_function>;
28134};
28135template <> struct describe_field_t<SgStatementFunctionStatement,SgExpression*,&SgStatementFunctionStatement::p_expression> {
28137 using field_type = SgExpression*;
28138 static constexpr size_t position{1};
28139 static constexpr char const * const name{"expression"};
28140 static constexpr char const * const typestr{"SgExpression*"};
28141 static constexpr bool traverse{true};
28142 static constexpr auto mbr_ptr{&SgStatementFunctionStatement::p_expression};
28143 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28144 using bind = Desc<SgStatementFunctionStatement, SgExpression* SgStatementFunctionStatement::*, &SgStatementFunctionStatement::p_expression>;
28145};
28149 static constexpr char const * const name{"StatementFunctionStatement"};
28150 static constexpr unsigned long variant{708};
28151 static constexpr bool concrete{true};
28152 using subclasses_t = mp::List<>;
28154};
28155template <> struct node_from_variant_t<708> { using type = SgStatementFunctionStatement; };
28156
28157// Class: StorageModifier
28158template <> struct describe_field_t<SgStorageModifier,SgStorageModifier::storage_modifier_enum,&SgStorageModifier::p_modifier> {
28159 using parent = SgStorageModifier;
28161 static constexpr size_t position{0};
28162 static constexpr char const * const name{"modifier"};
28163 static constexpr char const * const typestr{"SgStorageModifier::storage_modifier_enum"};
28164 static constexpr bool traverse{false};
28165 static constexpr auto mbr_ptr{&SgStorageModifier::p_modifier};
28166 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28167 using bind = Desc<SgStorageModifier, SgStorageModifier::storage_modifier_enum SgStorageModifier::*, &SgStorageModifier::p_modifier>;
28168};
28169template <> struct describe_field_t<SgStorageModifier,bool,&SgStorageModifier::p_thread_local_storage> {
28170 using parent = SgStorageModifier;
28171 using field_type = bool;
28172 static constexpr size_t position{1};
28173 static constexpr char const * const name{"thread_local_storage"};
28174 static constexpr char const * const typestr{"bool"};
28175 static constexpr bool traverse{false};
28176 static constexpr auto mbr_ptr{&SgStorageModifier::p_thread_local_storage};
28177 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28178 using bind = Desc<SgStorageModifier, bool SgStorageModifier::*, &SgStorageModifier::p_thread_local_storage>;
28179};
28181 using node = SgStorageModifier;
28182 using base = SgModifier;
28183 static constexpr char const * const name{"StorageModifier"};
28184 static constexpr unsigned long variant{709};
28185 static constexpr bool concrete{true};
28186 using subclasses_t = mp::List<>;
28188};
28189template <> struct node_from_variant_t<709> { using type = SgStorageModifier; };
28190
28191// Class: StringConversion
28193 using parent = SgStringConversion;
28194 using field_type = SgExpression*;
28195 static constexpr size_t position{0};
28196 static constexpr char const * const name{"expression"};
28197 static constexpr char const * const typestr{"SgExpression*"};
28198 static constexpr bool traverse{true};
28199 static constexpr auto mbr_ptr{&SgStringConversion::p_expression};
28200 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28201 using bind = Desc<SgStringConversion, SgExpression* SgStringConversion::*, &SgStringConversion::p_expression>;
28202};
28204 using node = SgStringConversion;
28205 using base = SgExpression;
28206 static constexpr char const * const name{"StringConversion"};
28207 static constexpr unsigned long variant{710};
28208 static constexpr bool concrete{true};
28209 using subclasses_t = mp::List<>;
28211};
28212template <> struct node_from_variant_t<710> { using type = SgStringConversion; };
28213
28214// Class: StringKeyedBidirectionalGraph
28217 using base = SgBidirectionalGraph;
28218 static constexpr char const * const name{"StringKeyedBidirectionalGraph"};
28219 static constexpr unsigned long variant{711};
28220 static constexpr bool concrete{true};
28221 using subclasses_t = mp::List<>;
28222 using fields_t = mp::List<>;
28223};
28224template <> struct node_from_variant_t<711> { using type = SgStringKeyedBidirectionalGraph; };
28225
28226// Class: StringVal
28227template <> struct describe_field_t<SgStringVal,std::string,&SgStringVal::p_value> {
28228 using parent = SgStringVal;
28229 using field_type = std::string;
28230 static constexpr size_t position{0};
28231 static constexpr char const * const name{"value"};
28232 static constexpr char const * const typestr{"std::string"};
28233 static constexpr bool traverse{false};
28234 static constexpr auto mbr_ptr{&SgStringVal::p_value};
28235 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28236 using bind = Desc<SgStringVal, std::string SgStringVal::*, &SgStringVal::p_value>;
28237};
28238template <> struct describe_field_t<SgStringVal,bool,&SgStringVal::p_wcharString> {
28239 using parent = SgStringVal;
28240 using field_type = bool;
28241 static constexpr size_t position{1};
28242 static constexpr char const * const name{"wcharString"};
28243 static constexpr char const * const typestr{"bool"};
28244 static constexpr bool traverse{false};
28245 static constexpr auto mbr_ptr{&SgStringVal::p_wcharString};
28246 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28247 using bind = Desc<SgStringVal, bool SgStringVal::*, &SgStringVal::p_wcharString>;
28248};
28249template <> struct describe_field_t<SgStringVal,char,&SgStringVal::p_stringDelimiter> {
28250 using parent = SgStringVal;
28251 using field_type = char;
28252 static constexpr size_t position{2};
28253 static constexpr char const * const name{"stringDelimiter"};
28254 static constexpr char const * const typestr{"char"};
28255 static constexpr bool traverse{false};
28256 static constexpr auto mbr_ptr{&SgStringVal::p_stringDelimiter};
28257 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28258 using bind = Desc<SgStringVal, char SgStringVal::*, &SgStringVal::p_stringDelimiter>;
28259};
28260template <> struct describe_field_t<SgStringVal,bool,&SgStringVal::p_is16bitString> {
28261 using parent = SgStringVal;
28262 using field_type = bool;
28263 static constexpr size_t position{3};
28264 static constexpr char const * const name{"is16bitString"};
28265 static constexpr char const * const typestr{"bool"};
28266 static constexpr bool traverse{false};
28267 static constexpr auto mbr_ptr{&SgStringVal::p_is16bitString};
28268 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28269 using bind = Desc<SgStringVal, bool SgStringVal::*, &SgStringVal::p_is16bitString>;
28270};
28271template <> struct describe_field_t<SgStringVal,bool,&SgStringVal::p_is32bitString> {
28272 using parent = SgStringVal;
28273 using field_type = bool;
28274 static constexpr size_t position{4};
28275 static constexpr char const * const name{"is32bitString"};
28276 static constexpr char const * const typestr{"bool"};
28277 static constexpr bool traverse{false};
28278 static constexpr auto mbr_ptr{&SgStringVal::p_is32bitString};
28279 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28280 using bind = Desc<SgStringVal, bool SgStringVal::*, &SgStringVal::p_is32bitString>;
28281};
28282template <> struct describe_field_t<SgStringVal,bool,&SgStringVal::p_isRawString> {
28283 using parent = SgStringVal;
28284 using field_type = bool;
28285 static constexpr size_t position{5};
28286 static constexpr char const * const name{"isRawString"};
28287 static constexpr char const * const typestr{"bool"};
28288 static constexpr bool traverse{false};
28289 static constexpr auto mbr_ptr{&SgStringVal::p_isRawString};
28290 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28291 using bind = Desc<SgStringVal, bool SgStringVal::*, &SgStringVal::p_isRawString>;
28292};
28293template <> struct describe_field_t<SgStringVal,std::string,&SgStringVal::p_raw_string_value> {
28294 using parent = SgStringVal;
28295 using field_type = std::string;
28296 static constexpr size_t position{6};
28297 static constexpr char const * const name{"raw_string_value"};
28298 static constexpr char const * const typestr{"std::string"};
28299 static constexpr bool traverse{false};
28300 static constexpr auto mbr_ptr{&SgStringVal::p_raw_string_value};
28301 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28302 using bind = Desc<SgStringVal, std::string SgStringVal::*, &SgStringVal::p_raw_string_value>;
28303};
28313template <> struct node_from_variant_t<712> { using type = SgStringVal; };
28314
28315// Class: StructureModifier
28316template <> struct describe_field_t<SgStructureModifier,SgStructureModifier::jovial_structure_modifier_enum,&SgStructureModifier::p_modifier> {
28319 static constexpr size_t position{0};
28320 static constexpr char const * const name{"modifier"};
28321 static constexpr char const * const typestr{"SgStructureModifier::jovial_structure_modifier_enum"};
28322 static constexpr bool traverse{false};
28323 static constexpr auto mbr_ptr{&SgStructureModifier::p_modifier};
28324 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28325 using bind = Desc<SgStructureModifier, SgStructureModifier::jovial_structure_modifier_enum SgStructureModifier::*, &SgStructureModifier::p_modifier>;
28326};
28327template <> struct describe_field_t<SgStructureModifier,int,&SgStructureModifier::p_bits_per_entry> {
28329 using field_type = int;
28330 static constexpr size_t position{1};
28331 static constexpr char const * const name{"bits_per_entry"};
28332 static constexpr char const * const typestr{"int"};
28333 static constexpr bool traverse{false};
28334 static constexpr auto mbr_ptr{&SgStructureModifier::p_bits_per_entry};
28335 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28336 using bind = Desc<SgStructureModifier, int SgStructureModifier::*, &SgStructureModifier::p_bits_per_entry>;
28337};
28339 using node = SgStructureModifier;
28340 using base = SgModifier;
28341 static constexpr char const * const name{"StructureModifier"};
28342 static constexpr unsigned long variant{713};
28343 static constexpr bool concrete{true};
28344 using subclasses_t = mp::List<>;
28346};
28347template <> struct node_from_variant_t<713> { using type = SgStructureModifier; };
28348
28349// Class: SubscriptExpression
28350template <> struct describe_field_t<SgSubscriptExpression,SgExpression*,&SgSubscriptExpression::p_lowerBound> {
28352 using field_type = SgExpression*;
28353 static constexpr size_t position{0};
28354 static constexpr char const * const name{"lowerBound"};
28355 static constexpr char const * const typestr{"SgExpression*"};
28356 static constexpr bool traverse{true};
28357 static constexpr auto mbr_ptr{&SgSubscriptExpression::p_lowerBound};
28358 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28359 using bind = Desc<SgSubscriptExpression, SgExpression* SgSubscriptExpression::*, &SgSubscriptExpression::p_lowerBound>;
28360};
28361template <> struct describe_field_t<SgSubscriptExpression,SgExpression*,&SgSubscriptExpression::p_upperBound> {
28363 using field_type = SgExpression*;
28364 static constexpr size_t position{1};
28365 static constexpr char const * const name{"upperBound"};
28366 static constexpr char const * const typestr{"SgExpression*"};
28367 static constexpr bool traverse{true};
28368 static constexpr auto mbr_ptr{&SgSubscriptExpression::p_upperBound};
28369 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28370 using bind = Desc<SgSubscriptExpression, SgExpression* SgSubscriptExpression::*, &SgSubscriptExpression::p_upperBound>;
28371};
28372template <> struct describe_field_t<SgSubscriptExpression,SgExpression*,&SgSubscriptExpression::p_stride> {
28374 using field_type = SgExpression*;
28375 static constexpr size_t position{2};
28376 static constexpr char const * const name{"stride"};
28377 static constexpr char const * const typestr{"SgExpression*"};
28378 static constexpr bool traverse{true};
28379 static constexpr auto mbr_ptr{&SgSubscriptExpression::p_stride};
28380 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28381 using bind = Desc<SgSubscriptExpression, SgExpression* SgSubscriptExpression::*, &SgSubscriptExpression::p_stride>;
28382};
28385 using base = SgExpression;
28386 static constexpr char const * const name{"SubscriptExpression"};
28387 static constexpr unsigned long variant{714};
28388 static constexpr bool concrete{true};
28389 using subclasses_t = mp::List<>;
28391};
28392template <> struct node_from_variant_t<714> { using type = SgSubscriptExpression; };
28393
28394// Class: SubtractOp
28395template <> struct describe_node_t<SgSubtractOp> {
28396 using node = SgSubtractOp;
28397 using base = SgBinaryOp;
28398 static constexpr char const * const name{"SubtractOp"};
28399 static constexpr unsigned long variant{715};
28400 static constexpr bool concrete{true};
28401 using subclasses_t = mp::List<>;
28402 using fields_t = mp::List<>;
28403};
28404template <> struct node_from_variant_t<715> { using type = SgSubtractOp; };
28405
28406// Class: Support
28416template <> struct node_from_variant_t<716> { using type = SgSupport; };
28417
28418// Class: SwitchStatement
28419template <> struct describe_field_t<SgSwitchStatement,SgStatement*,&SgSwitchStatement::p_item_selector> {
28420 using parent = SgSwitchStatement;
28421 using field_type = SgStatement*;
28422 static constexpr size_t position{0};
28423 static constexpr char const * const name{"item_selector"};
28424 static constexpr char const * const typestr{"SgStatement*"};
28425 static constexpr bool traverse{true};
28426 static constexpr auto mbr_ptr{&SgSwitchStatement::p_item_selector};
28427 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28428 using bind = Desc<SgSwitchStatement, SgStatement* SgSwitchStatement::*, &SgSwitchStatement::p_item_selector>;
28429};
28431 using parent = SgSwitchStatement;
28432 using field_type = SgStatement*;
28433 static constexpr size_t position{1};
28434 static constexpr char const * const name{"body"};
28435 static constexpr char const * const typestr{"SgStatement*"};
28436 static constexpr bool traverse{true};
28437 static constexpr auto mbr_ptr{&SgSwitchStatement::p_body};
28438 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28439 using bind = Desc<SgSwitchStatement, SgStatement* SgSwitchStatement::*, &SgSwitchStatement::p_body>;
28440};
28441template <> struct describe_field_t<SgSwitchStatement,SgLabelRefExp*,&SgSwitchStatement::p_end_numeric_label> {
28442 using parent = SgSwitchStatement;
28443 using field_type = SgLabelRefExp*;
28444 static constexpr size_t position{2};
28445 static constexpr char const * const name{"end_numeric_label"};
28446 static constexpr char const * const typestr{"SgLabelRefExp*"};
28447 static constexpr bool traverse{false};
28448 static constexpr auto mbr_ptr{&SgSwitchStatement::p_end_numeric_label};
28449 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28450 using bind = Desc<SgSwitchStatement, SgLabelRefExp* SgSwitchStatement::*, &SgSwitchStatement::p_end_numeric_label>;
28451};
28452template <> struct describe_field_t<SgSwitchStatement,std::string,&SgSwitchStatement::p_string_label> {
28453 using parent = SgSwitchStatement;
28454 using field_type = std::string;
28455 static constexpr size_t position{3};
28456 static constexpr char const * const name{"string_label"};
28457 static constexpr char const * const typestr{"std::string"};
28458 static constexpr bool traverse{false};
28459 static constexpr auto mbr_ptr{&SgSwitchStatement::p_string_label};
28460 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28461 using bind = Desc<SgSwitchStatement, std::string SgSwitchStatement::*, &SgSwitchStatement::p_string_label>;
28462};
28472template <> struct node_from_variant_t<717> { using type = SgSwitchStatement; };
28473
28474// Class: Symbol
28475template <> struct describe_field_t<SgSymbol,AstAttributeMechanism*,&SgSymbol::p_attributeMechanism> {
28476 using parent = SgSymbol;
28478 static constexpr size_t position{0};
28479 static constexpr char const * const name{"attributeMechanism"};
28480 static constexpr char const * const typestr{"AstAttributeMechanism*"};
28481 static constexpr bool traverse{false};
28482 static constexpr auto mbr_ptr{&SgSymbol::p_attributeMechanism};
28483 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28484 using bind = Desc<SgSymbol, AstAttributeMechanism* SgSymbol::*, &SgSymbol::p_attributeMechanism>;
28485};
28495template <> struct node_from_variant_t<718> { using type = SgSymbol; };
28496
28497// Class: SymbolTable
28499 using parent = SgSymbolTable;
28500 using field_type = SgSymbolTable::hash_iterator;
28501 static constexpr size_t position{0};
28502 static constexpr char const * const name{"iterator"};
28503 static constexpr char const * const typestr{"SgSymbolTable::hash_iterator"};
28504 static constexpr bool traverse{false};
28505 static constexpr auto mbr_ptr{&SgSymbolTable::p_iterator};
28506 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28507 using bind = Desc<SgSymbolTable, SgSymbolTable::hash_iterator SgSymbolTable::*, &SgSymbolTable::p_iterator>;
28508};
28510 using parent = SgSymbolTable;
28511 using field_type = SgName;
28512 static constexpr size_t position{1};
28513 static constexpr char const * const name{"name"};
28514 static constexpr char const * const typestr{"SgName"};
28515 static constexpr bool traverse{false};
28516 static constexpr auto mbr_ptr{&SgSymbolTable::p_name};
28517 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28518 using bind = Desc<SgSymbolTable, SgName SgSymbolTable::*, &SgSymbolTable::p_name>;
28519};
28521 using parent = SgSymbolTable;
28522 using field_type = bool;
28523 static constexpr size_t position{2};
28524 static constexpr char const * const name{"no_name"};
28525 static constexpr char const * const typestr{"bool"};
28526 static constexpr bool traverse{false};
28527 static constexpr auto mbr_ptr{&SgSymbolTable::p_no_name};
28528 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28529 using bind = Desc<SgSymbolTable, bool SgSymbolTable::*, &SgSymbolTable::p_no_name>;
28530};
28532 using parent = SgSymbolTable;
28534 static constexpr size_t position{3};
28535 static constexpr char const * const name{"table"};
28536 static constexpr char const * const typestr{" rose_hash_multimap*"};
28537 static constexpr bool traverse{false};
28538 static constexpr auto mbr_ptr{&SgSymbolTable::p_table};
28539 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28540 using bind = Desc<SgSymbolTable, rose_hash_multimap* SgSymbolTable::*, &SgSymbolTable::p_table>;
28541};
28542template <> struct describe_field_t<SgSymbolTable,SgNodeSet,&SgSymbolTable::p_symbolSet> {
28543 using parent = SgSymbolTable;
28544 using field_type = SgNodeSet;
28545 static constexpr size_t position{4};
28546 static constexpr char const * const name{"symbolSet"};
28547 static constexpr char const * const typestr{"SgNodeSet"};
28548 static constexpr bool traverse{false};
28549 static constexpr auto mbr_ptr{&SgSymbolTable::p_symbolSet};
28550 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28551 using bind = Desc<SgSymbolTable, SgNodeSet SgSymbolTable::*, &SgSymbolTable::p_symbolSet>;
28552};
28553template <> struct describe_field_t<SgSymbolTable,bool,&SgSymbolTable::p_case_insensitive> {
28554 using parent = SgSymbolTable;
28555 using field_type = bool;
28556 static constexpr size_t position{5};
28557 static constexpr char const * const name{"case_insensitive"};
28558 static constexpr char const * const typestr{"bool"};
28559 static constexpr bool traverse{false};
28560 static constexpr auto mbr_ptr{&SgSymbolTable::p_case_insensitive};
28561 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28562 using bind = Desc<SgSymbolTable, bool SgSymbolTable::*, &SgSymbolTable::p_case_insensitive>;
28563};
28573template <> struct node_from_variant_t<719> { using type = SgSymbolTable; };
28574
28575// Class: TemplateArgument
28576template <> struct describe_field_t<SgTemplateArgument,SgTemplateArgument::template_argument_enum,&SgTemplateArgument::p_argumentType> {
28577 using parent = SgTemplateArgument;
28579 static constexpr size_t position{0};
28580 static constexpr char const * const name{"argumentType"};
28581 static constexpr char const * const typestr{"SgTemplateArgument::template_argument_enum"};
28582 static constexpr bool traverse{false};
28583 static constexpr auto mbr_ptr{&SgTemplateArgument::p_argumentType};
28584 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28585 using bind = Desc<SgTemplateArgument, SgTemplateArgument::template_argument_enum SgTemplateArgument::*, &SgTemplateArgument::p_argumentType>;
28586};
28588 using parent = SgTemplateArgument;
28589 using field_type = bool;
28590 static constexpr size_t position{1};
28591 static constexpr char const * const name{"isArrayBoundUnknownType"};
28592 static constexpr char const * const typestr{"bool"};
28593 static constexpr bool traverse{false};
28594 static constexpr auto mbr_ptr{&SgTemplateArgument::p_isArrayBoundUnknownType};
28595 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28596 using bind = Desc<SgTemplateArgument, bool SgTemplateArgument::*, &SgTemplateArgument::p_isArrayBoundUnknownType>;
28597};
28599 using parent = SgTemplateArgument;
28600 using field_type = SgType*;
28601 static constexpr size_t position{2};
28602 static constexpr char const * const name{"type"};
28603 static constexpr char const * const typestr{"SgType*"};
28604 static constexpr bool traverse{false};
28605 static constexpr auto mbr_ptr{&SgTemplateArgument::p_type};
28606 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28607 using bind = Desc<SgTemplateArgument, SgType* SgTemplateArgument::*, &SgTemplateArgument::p_type>;
28608};
28609template <> struct describe_field_t<SgTemplateArgument,SgType*,&SgTemplateArgument::p_unparsable_type_alias> {
28610 using parent = SgTemplateArgument;
28611 using field_type = SgType*;
28612 static constexpr size_t position{3};
28613 static constexpr char const * const name{"unparsable_type_alias"};
28614 static constexpr char const * const typestr{"SgType*"};
28615 static constexpr bool traverse{false};
28616 static constexpr auto mbr_ptr{&SgTemplateArgument::p_unparsable_type_alias};
28617 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28618 using bind = Desc<SgTemplateArgument, SgType* SgTemplateArgument::*, &SgTemplateArgument::p_unparsable_type_alias>;
28619};
28621 using parent = SgTemplateArgument;
28622 using field_type = SgExpression*;
28623 static constexpr size_t position{4};
28624 static constexpr char const * const name{"expression"};
28625 static constexpr char const * const typestr{"SgExpression*"};
28626 static constexpr bool traverse{true};
28627 static constexpr auto mbr_ptr{&SgTemplateArgument::p_expression};
28628 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28629 using bind = Desc<SgTemplateArgument, SgExpression* SgTemplateArgument::*, &SgTemplateArgument::p_expression>;
28630};
28631template <> struct describe_field_t<SgTemplateArgument,SgDeclarationStatement*,&SgTemplateArgument::p_templateDeclaration> {
28632 using parent = SgTemplateArgument;
28634 static constexpr size_t position{5};
28635 static constexpr char const * const name{"templateDeclaration"};
28636 static constexpr char const * const typestr{"SgDeclarationStatement*"};
28637 static constexpr bool traverse{true};
28638 static constexpr auto mbr_ptr{&SgTemplateArgument::p_templateDeclaration};
28639 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28640 using bind = Desc<SgTemplateArgument, SgDeclarationStatement* SgTemplateArgument::*, &SgTemplateArgument::p_templateDeclaration>;
28641};
28642template <> struct describe_field_t<SgTemplateArgument,SgInitializedName*,&SgTemplateArgument::p_initializedName> {
28643 using parent = SgTemplateArgument;
28645 static constexpr size_t position{6};
28646 static constexpr char const * const name{"initializedName"};
28647 static constexpr char const * const typestr{"SgInitializedName*"};
28648 static constexpr bool traverse{true};
28649 static constexpr auto mbr_ptr{&SgTemplateArgument::p_initializedName};
28650 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28651 using bind = Desc<SgTemplateArgument, SgInitializedName* SgTemplateArgument::*, &SgTemplateArgument::p_initializedName>;
28652};
28654 using parent = SgTemplateArgument;
28655 using field_type = bool;
28656 static constexpr size_t position{7};
28657 static constexpr char const * const name{"explicitlySpecified"};
28658 static constexpr char const * const typestr{"bool"};
28659 static constexpr bool traverse{false};
28660 static constexpr auto mbr_ptr{&SgTemplateArgument::p_explicitlySpecified};
28661 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28662 using bind = Desc<SgTemplateArgument, bool SgTemplateArgument::*, &SgTemplateArgument::p_explicitlySpecified>;
28663};
28664template <> struct describe_field_t<SgTemplateArgument,int,&SgTemplateArgument::p_name_qualification_length> {
28665 using parent = SgTemplateArgument;
28666 using field_type = int;
28667 static constexpr size_t position{8};
28668 static constexpr char const * const name{"name_qualification_length"};
28669 static constexpr char const * const typestr{"int"};
28670 static constexpr bool traverse{false};
28671 static constexpr auto mbr_ptr{&SgTemplateArgument::p_name_qualification_length};
28672 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28673 using bind = Desc<SgTemplateArgument, int SgTemplateArgument::*, &SgTemplateArgument::p_name_qualification_length>;
28674};
28675template <> struct describe_field_t<SgTemplateArgument,bool,&SgTemplateArgument::p_type_elaboration_required> {
28676 using parent = SgTemplateArgument;
28677 using field_type = bool;
28678 static constexpr size_t position{9};
28679 static constexpr char const * const name{"type_elaboration_required"};
28680 static constexpr char const * const typestr{"bool"};
28681 static constexpr bool traverse{false};
28682 static constexpr auto mbr_ptr{&SgTemplateArgument::p_type_elaboration_required};
28683 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28684 using bind = Desc<SgTemplateArgument, bool SgTemplateArgument::*, &SgTemplateArgument::p_type_elaboration_required>;
28685};
28686template <> struct describe_field_t<SgTemplateArgument,bool,&SgTemplateArgument::p_global_qualification_required> {
28687 using parent = SgTemplateArgument;
28688 using field_type = bool;
28689 static constexpr size_t position{10};
28690 static constexpr char const * const name{"global_qualification_required"};
28691 static constexpr char const * const typestr{"bool"};
28692 static constexpr bool traverse{false};
28693 static constexpr auto mbr_ptr{&SgTemplateArgument::p_global_qualification_required};
28694 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28695 using bind = Desc<SgTemplateArgument, bool SgTemplateArgument::*, &SgTemplateArgument::p_global_qualification_required>;
28696};
28697template <> struct describe_field_t<SgTemplateArgument,bool,&SgTemplateArgument::p_requiresGlobalNameQualificationOnType> {
28698 using parent = SgTemplateArgument;
28699 using field_type = bool;
28700 static constexpr size_t position{11};
28701 static constexpr char const * const name{"requiresGlobalNameQualificationOnType"};
28702 static constexpr char const * const typestr{"bool"};
28703 static constexpr bool traverse{false};
28704 static constexpr auto mbr_ptr{&SgTemplateArgument::p_requiresGlobalNameQualificationOnType};
28705 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28706 using bind = Desc<SgTemplateArgument, bool SgTemplateArgument::*, &SgTemplateArgument::p_requiresGlobalNameQualificationOnType>;
28707};
28708template <> struct describe_field_t<SgTemplateArgument,int,&SgTemplateArgument::p_name_qualification_length_for_type> {
28709 using parent = SgTemplateArgument;
28710 using field_type = int;
28711 static constexpr size_t position{12};
28712 static constexpr char const * const name{"name_qualification_length_for_type"};
28713 static constexpr char const * const typestr{"int"};
28714 static constexpr bool traverse{false};
28715 static constexpr auto mbr_ptr{&SgTemplateArgument::p_name_qualification_length_for_type};
28716 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28717 using bind = Desc<SgTemplateArgument, int SgTemplateArgument::*, &SgTemplateArgument::p_name_qualification_length_for_type>;
28718};
28719template <> struct describe_field_t<SgTemplateArgument,bool,&SgTemplateArgument::p_type_elaboration_required_for_type> {
28720 using parent = SgTemplateArgument;
28721 using field_type = bool;
28722 static constexpr size_t position{13};
28723 static constexpr char const * const name{"type_elaboration_required_for_type"};
28724 static constexpr char const * const typestr{"bool"};
28725 static constexpr bool traverse{false};
28726 static constexpr auto mbr_ptr{&SgTemplateArgument::p_type_elaboration_required_for_type};
28727 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28728 using bind = Desc<SgTemplateArgument, bool SgTemplateArgument::*, &SgTemplateArgument::p_type_elaboration_required_for_type>;
28729};
28730template <> struct describe_field_t<SgTemplateArgument,bool,&SgTemplateArgument::p_global_qualification_required_for_type> {
28731 using parent = SgTemplateArgument;
28732 using field_type = bool;
28733 static constexpr size_t position{14};
28734 static constexpr char const * const name{"global_qualification_required_for_type"};
28735 static constexpr char const * const typestr{"bool"};
28736 static constexpr bool traverse{false};
28737 static constexpr auto mbr_ptr{&SgTemplateArgument::p_global_qualification_required_for_type};
28738 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28739 using bind = Desc<SgTemplateArgument, bool SgTemplateArgument::*, &SgTemplateArgument::p_global_qualification_required_for_type>;
28740};
28741template <> struct describe_field_t<SgTemplateArgument,SgTemplateArgument*,&SgTemplateArgument::p_previous_instance> {
28742 using parent = SgTemplateArgument;
28744 static constexpr size_t position{15};
28745 static constexpr char const * const name{"previous_instance"};
28746 static constexpr char const * const typestr{"SgTemplateArgument*"};
28747 static constexpr bool traverse{false};
28748 static constexpr auto mbr_ptr{&SgTemplateArgument::p_previous_instance};
28749 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28750 using bind = Desc<SgTemplateArgument, SgTemplateArgument* SgTemplateArgument::*, &SgTemplateArgument::p_previous_instance>;
28751};
28752template <> struct describe_field_t<SgTemplateArgument,SgTemplateArgument*,&SgTemplateArgument::p_next_instance> {
28753 using parent = SgTemplateArgument;
28755 static constexpr size_t position{16};
28756 static constexpr char const * const name{"next_instance"};
28757 static constexpr char const * const typestr{"SgTemplateArgument*"};
28758 static constexpr bool traverse{false};
28759 static constexpr auto mbr_ptr{&SgTemplateArgument::p_next_instance};
28760 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28761 using bind = Desc<SgTemplateArgument, SgTemplateArgument* SgTemplateArgument::*, &SgTemplateArgument::p_next_instance>;
28762};
28763template <> struct describe_field_t<SgTemplateArgument,bool,&SgTemplateArgument::p_is_pack_element> {
28764 using parent = SgTemplateArgument;
28765 using field_type = bool;
28766 static constexpr size_t position{17};
28767 static constexpr char const * const name{"is_pack_element"};
28768 static constexpr char const * const typestr{"bool"};
28769 static constexpr bool traverse{false};
28770 static constexpr auto mbr_ptr{&SgTemplateArgument::p_is_pack_element};
28771 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28772 using bind = Desc<SgTemplateArgument, bool SgTemplateArgument::*, &SgTemplateArgument::p_is_pack_element>;
28773};
28775 using node = SgTemplateArgument;
28776 using base = SgSupport;
28777 static constexpr char const * const name{"TemplateArgument"};
28778 static constexpr unsigned long variant{720};
28779 static constexpr bool concrete{true};
28780 using subclasses_t = mp::List<>;
28781 using fields_t = mp::List<describe_field_t<SgTemplateArgument,SgTemplateArgument::template_argument_enum,&SgTemplateArgument::p_argumentType>, describe_field_t<SgTemplateArgument,bool,&SgTemplateArgument::p_isArrayBoundUnknownType>, describe_field_t<SgTemplateArgument,SgType*,&SgTemplateArgument::p_type>, describe_field_t<SgTemplateArgument,SgType*,&SgTemplateArgument::p_unparsable_type_alias>, describe_field_t<SgTemplateArgument,SgExpression*,&SgTemplateArgument::p_expression>, describe_field_t<SgTemplateArgument,SgDeclarationStatement*,&SgTemplateArgument::p_templateDeclaration>, describe_field_t<SgTemplateArgument,SgInitializedName*,&SgTemplateArgument::p_initializedName>, describe_field_t<SgTemplateArgument,bool,&SgTemplateArgument::p_explicitlySpecified>, describe_field_t<SgTemplateArgument,int,&SgTemplateArgument::p_name_qualification_length>, describe_field_t<SgTemplateArgument,bool,&SgTemplateArgument::p_type_elaboration_required>, describe_field_t<SgTemplateArgument,bool,&SgTemplateArgument::p_global_qualification_required>, describe_field_t<SgTemplateArgument,bool,&SgTemplateArgument::p_requiresGlobalNameQualificationOnType>, describe_field_t<SgTemplateArgument,int,&SgTemplateArgument::p_name_qualification_length_for_type>, describe_field_t<SgTemplateArgument,bool,&SgTemplateArgument::p_type_elaboration_required_for_type>, describe_field_t<SgTemplateArgument,bool,&SgTemplateArgument::p_global_qualification_required_for_type>, describe_field_t<SgTemplateArgument,SgTemplateArgument*,&SgTemplateArgument::p_previous_instance>, describe_field_t<SgTemplateArgument,SgTemplateArgument*,&SgTemplateArgument::p_next_instance>, describe_field_t<SgTemplateArgument,bool,&SgTemplateArgument::p_is_pack_element>>;
28782};
28783template <> struct node_from_variant_t<720> { using type = SgTemplateArgument; };
28784
28785// Class: TemplateArgumentList
28786template <> struct describe_field_t<SgTemplateArgumentList,SgTemplateArgumentPtrList,&SgTemplateArgumentList::p_args> {
28788 using field_type = SgTemplateArgumentPtrList;
28789 static constexpr size_t position{0};
28790 static constexpr char const * const name{"args"};
28791 static constexpr char const * const typestr{"SgTemplateArgumentPtrList"};
28792 static constexpr bool traverse{true};
28793 static constexpr auto mbr_ptr{&SgTemplateArgumentList::p_args};
28794 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28795 using bind = Desc<SgTemplateArgumentList, SgTemplateArgumentPtrList SgTemplateArgumentList::*, &SgTemplateArgumentList::p_args>;
28796};
28799 using base = SgSupport;
28800 static constexpr char const * const name{"TemplateArgumentList"};
28801 static constexpr unsigned long variant{721};
28802 static constexpr bool concrete{true};
28803 using subclasses_t = mp::List<>;
28805};
28806template <> struct node_from_variant_t<721> { using type = SgTemplateArgumentList; };
28807
28808// Class: TemplateDeclaration
28811 using field_type = SgName;
28812 static constexpr size_t position{0};
28813 static constexpr char const * const name{"name"};
28814 static constexpr char const * const typestr{"SgName"};
28815 static constexpr bool traverse{false};
28816 static constexpr auto mbr_ptr{&SgTemplateDeclaration::p_name};
28817 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28818 using bind = Desc<SgTemplateDeclaration, SgName SgTemplateDeclaration::*, &SgTemplateDeclaration::p_name>;
28819};
28822 using field_type = SgName;
28823 static constexpr size_t position{1};
28824 static constexpr char const * const name{"string"};
28825 static constexpr char const * const typestr{"SgName"};
28826 static constexpr bool traverse{false};
28827 static constexpr auto mbr_ptr{&SgTemplateDeclaration::p_string};
28828 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28829 using bind = Desc<SgTemplateDeclaration, SgName SgTemplateDeclaration::*, &SgTemplateDeclaration::p_string>;
28830};
28834 static constexpr size_t position{2};
28835 static constexpr char const * const name{"template_kind"};
28836 static constexpr char const * const typestr{"SgTemplateDeclaration::template_type_enum"};
28837 static constexpr bool traverse{false};
28838 static constexpr auto mbr_ptr{&SgTemplateDeclaration::p_template_kind};
28839 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28840 using bind = Desc<SgTemplateDeclaration, SgTemplateDeclaration::template_type_enum SgTemplateDeclaration::*, &SgTemplateDeclaration::p_template_kind>;
28841};
28844 using field_type = SgTemplateParameterPtrList;
28845 static constexpr size_t position{3};
28846 static constexpr char const * const name{"templateParameters"};
28847 static constexpr char const * const typestr{"SgTemplateParameterPtrList"};
28848 static constexpr bool traverse{false};
28849 static constexpr auto mbr_ptr{&SgTemplateDeclaration::p_templateParameters};
28850 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28851 using bind = Desc<SgTemplateDeclaration, SgTemplateParameterPtrList SgTemplateDeclaration::*, &SgTemplateDeclaration::p_templateParameters>;
28852};
28856 static constexpr size_t position{4};
28857 static constexpr char const * const name{"scope"};
28858 static constexpr char const * const typestr{"SgScopeStatement*"};
28859 static constexpr bool traverse{false};
28860 static constexpr auto mbr_ptr{&SgTemplateDeclaration::p_scope};
28861 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28862 using bind = Desc<SgTemplateDeclaration, SgScopeStatement* SgTemplateDeclaration::*, &SgTemplateDeclaration::p_scope>;
28863};
28864template <> struct describe_field_t<SgTemplateDeclaration,SgDeclarationScope*,&SgTemplateDeclaration::p_nonreal_decl_scope> {
28867 static constexpr size_t position{5};
28868 static constexpr char const * const name{"nonreal_decl_scope"};
28869 static constexpr char const * const typestr{"SgDeclarationScope*"};
28870 static constexpr bool traverse{false};
28871 static constexpr auto mbr_ptr{&SgTemplateDeclaration::p_nonreal_decl_scope};
28872 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28873 using bind = Desc<SgTemplateDeclaration, SgDeclarationScope* SgTemplateDeclaration::*, &SgTemplateDeclaration::p_nonreal_decl_scope>;
28874};
28884template <> struct node_from_variant_t<722> { using type = SgTemplateDeclaration; };
28885
28886// Class: TemplateClassDeclaration
28887template <> struct describe_field_t<SgTemplateClassDeclaration,SgTemplateParameterPtrList,&SgTemplateClassDeclaration::p_templateParameters> {
28889 using field_type = SgTemplateParameterPtrList;
28890 static constexpr size_t position{0};
28891 static constexpr char const * const name{"templateParameters"};
28892 static constexpr char const * const typestr{"SgTemplateParameterPtrList"};
28893 static constexpr bool traverse{false};
28894 static constexpr auto mbr_ptr{&SgTemplateClassDeclaration::p_templateParameters};
28895 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28896 using bind = Desc<SgTemplateClassDeclaration, SgTemplateParameterPtrList SgTemplateClassDeclaration::*, &SgTemplateClassDeclaration::p_templateParameters>;
28897};
28898template <> struct describe_field_t<SgTemplateClassDeclaration,SgTemplateArgumentPtrList,&SgTemplateClassDeclaration::p_templateSpecializationArguments> {
28900 using field_type = SgTemplateArgumentPtrList;
28901 static constexpr size_t position{1};
28902 static constexpr char const * const name{"templateSpecializationArguments"};
28903 static constexpr char const * const typestr{"SgTemplateArgumentPtrList"};
28904 static constexpr bool traverse{false};
28905 static constexpr auto mbr_ptr{&SgTemplateClassDeclaration::p_templateSpecializationArguments};
28906 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28907 using bind = Desc<SgTemplateClassDeclaration, SgTemplateArgumentPtrList SgTemplateClassDeclaration::*, &SgTemplateClassDeclaration::p_templateSpecializationArguments>;
28908};
28909template <> struct describe_field_t<SgTemplateClassDeclaration,SgName,&SgTemplateClassDeclaration::p_string> {
28911 using field_type = SgName;
28912 static constexpr size_t position{2};
28913 static constexpr char const * const name{"string"};
28914 static constexpr char const * const typestr{"SgName"};
28915 static constexpr bool traverse{false};
28916 static constexpr auto mbr_ptr{&SgTemplateClassDeclaration::p_string};
28917 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28918 using bind = Desc<SgTemplateClassDeclaration, SgName SgTemplateClassDeclaration::*, &SgTemplateClassDeclaration::p_string>;
28919};
28920template <> struct describe_field_t<SgTemplateClassDeclaration,SgName,&SgTemplateClassDeclaration::p_templateName> {
28922 using field_type = SgName;
28923 static constexpr size_t position{3};
28924 static constexpr char const * const name{"templateName"};
28925 static constexpr char const * const typestr{"SgName"};
28926 static constexpr bool traverse{false};
28927 static constexpr auto mbr_ptr{&SgTemplateClassDeclaration::p_templateName};
28928 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28929 using bind = Desc<SgTemplateClassDeclaration, SgName SgTemplateClassDeclaration::*, &SgTemplateClassDeclaration::p_templateName>;
28930};
28931template <> struct describe_field_t<SgTemplateClassDeclaration,SgDeclarationScope*,&SgTemplateClassDeclaration::p_nonreal_decl_scope> {
28934 static constexpr size_t position{4};
28935 static constexpr char const * const name{"nonreal_decl_scope"};
28936 static constexpr char const * const typestr{"SgDeclarationScope*"};
28937 static constexpr bool traverse{false};
28938 static constexpr auto mbr_ptr{&SgTemplateClassDeclaration::p_nonreal_decl_scope};
28939 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28940 using bind = Desc<SgTemplateClassDeclaration, SgDeclarationScope* SgTemplateClassDeclaration::*, &SgTemplateClassDeclaration::p_nonreal_decl_scope>;
28941};
28951template <> struct node_from_variant_t<723> { using type = SgTemplateClassDeclaration; };
28952
28953// Class: TemplateClassSymbol
28956 using base = SgClassSymbol;
28957 static constexpr char const * const name{"TemplateClassSymbol"};
28958 static constexpr unsigned long variant{724};
28959 static constexpr bool concrete{true};
28960 using subclasses_t = mp::List<>;
28961 using fields_t = mp::List<>;
28962};
28963template <> struct node_from_variant_t<724> { using type = SgTemplateClassSymbol; };
28964
28965// Class: TemplateFunctionDeclaration
28966template <> struct describe_field_t<SgTemplateFunctionDeclaration,SgTemplateParameterPtrList,&SgTemplateFunctionDeclaration::p_templateParameters> {
28968 using field_type = SgTemplateParameterPtrList;
28969 static constexpr size_t position{0};
28970 static constexpr char const * const name{"templateParameters"};
28971 static constexpr char const * const typestr{"SgTemplateParameterPtrList"};
28972 static constexpr bool traverse{false};
28973 static constexpr auto mbr_ptr{&SgTemplateFunctionDeclaration::p_templateParameters};
28974 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28975 using bind = Desc<SgTemplateFunctionDeclaration, SgTemplateParameterPtrList SgTemplateFunctionDeclaration::*, &SgTemplateFunctionDeclaration::p_templateParameters>;
28976};
28977template <> struct describe_field_t<SgTemplateFunctionDeclaration,SgTemplateArgumentPtrList,&SgTemplateFunctionDeclaration::p_templateSpecializationArguments> {
28979 using field_type = SgTemplateArgumentPtrList;
28980 static constexpr size_t position{1};
28981 static constexpr char const * const name{"templateSpecializationArguments"};
28982 static constexpr char const * const typestr{"SgTemplateArgumentPtrList"};
28983 static constexpr bool traverse{false};
28984 static constexpr auto mbr_ptr{&SgTemplateFunctionDeclaration::p_templateSpecializationArguments};
28985 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28986 using bind = Desc<SgTemplateFunctionDeclaration, SgTemplateArgumentPtrList SgTemplateFunctionDeclaration::*, &SgTemplateFunctionDeclaration::p_templateSpecializationArguments>;
28987};
28988template <> struct describe_field_t<SgTemplateFunctionDeclaration,SgName,&SgTemplateFunctionDeclaration::p_string> {
28990 using field_type = SgName;
28991 static constexpr size_t position{2};
28992 static constexpr char const * const name{"string"};
28993 static constexpr char const * const typestr{"SgName"};
28994 static constexpr bool traverse{false};
28995 static constexpr auto mbr_ptr{&SgTemplateFunctionDeclaration::p_string};
28996 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
28997 using bind = Desc<SgTemplateFunctionDeclaration, SgName SgTemplateFunctionDeclaration::*, &SgTemplateFunctionDeclaration::p_string>;
28998};
28999template <> struct describe_field_t<SgTemplateFunctionDeclaration,bool,&SgTemplateFunctionDeclaration::p_string_represents_function_body> {
29001 using field_type = bool;
29002 static constexpr size_t position{3};
29003 static constexpr char const * const name{"string_represents_function_body"};
29004 static constexpr char const * const typestr{"bool"};
29005 static constexpr bool traverse{false};
29006 static constexpr auto mbr_ptr{&SgTemplateFunctionDeclaration::p_string_represents_function_body};
29007 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29008 using bind = Desc<SgTemplateFunctionDeclaration, bool SgTemplateFunctionDeclaration::*, &SgTemplateFunctionDeclaration::p_string_represents_function_body>;
29009};
29010template <> struct describe_field_t<SgTemplateFunctionDeclaration,SgDeclarationScope*,&SgTemplateFunctionDeclaration::p_nonreal_decl_scope> {
29013 static constexpr size_t position{4};
29014 static constexpr char const * const name{"nonreal_decl_scope"};
29015 static constexpr char const * const typestr{"SgDeclarationScope*"};
29016 static constexpr bool traverse{false};
29017 static constexpr auto mbr_ptr{&SgTemplateFunctionDeclaration::p_nonreal_decl_scope};
29018 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29019 using bind = Desc<SgTemplateFunctionDeclaration, SgDeclarationScope* SgTemplateFunctionDeclaration::*, &SgTemplateFunctionDeclaration::p_nonreal_decl_scope>;
29020};
29030template <> struct node_from_variant_t<725> { using type = SgTemplateFunctionDeclaration; };
29031
29032// Class: TemplateFunctionRefExp
29033template <> struct describe_field_t<SgTemplateFunctionRefExp,SgTemplateFunctionSymbol*,&SgTemplateFunctionRefExp::p_symbol_i> {
29036 static constexpr size_t position{0};
29037 static constexpr char const * const name{"symbol_i"};
29038 static constexpr char const * const typestr{"SgTemplateFunctionSymbol*"};
29039 static constexpr bool traverse{false};
29040 static constexpr auto mbr_ptr{&SgTemplateFunctionRefExp::p_symbol_i};
29041 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29042 using bind = Desc<SgTemplateFunctionRefExp, SgTemplateFunctionSymbol* SgTemplateFunctionRefExp::*, &SgTemplateFunctionRefExp::p_symbol_i>;
29043};
29044template <> struct describe_field_t<SgTemplateFunctionRefExp,int,&SgTemplateFunctionRefExp::p_name_qualification_length> {
29046 using field_type = int;
29047 static constexpr size_t position{1};
29048 static constexpr char const * const name{"name_qualification_length"};
29049 static constexpr char const * const typestr{"int"};
29050 static constexpr bool traverse{false};
29051 static constexpr auto mbr_ptr{&SgTemplateFunctionRefExp::p_name_qualification_length};
29052 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29053 using bind = Desc<SgTemplateFunctionRefExp, int SgTemplateFunctionRefExp::*, &SgTemplateFunctionRefExp::p_name_qualification_length>;
29054};
29055template <> struct describe_field_t<SgTemplateFunctionRefExp,bool,&SgTemplateFunctionRefExp::p_type_elaboration_required> {
29057 using field_type = bool;
29058 static constexpr size_t position{2};
29059 static constexpr char const * const name{"type_elaboration_required"};
29060 static constexpr char const * const typestr{"bool"};
29061 static constexpr bool traverse{false};
29062 static constexpr auto mbr_ptr{&SgTemplateFunctionRefExp::p_type_elaboration_required};
29063 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29064 using bind = Desc<SgTemplateFunctionRefExp, bool SgTemplateFunctionRefExp::*, &SgTemplateFunctionRefExp::p_type_elaboration_required>;
29065};
29066template <> struct describe_field_t<SgTemplateFunctionRefExp,bool,&SgTemplateFunctionRefExp::p_global_qualification_required> {
29068 using field_type = bool;
29069 static constexpr size_t position{3};
29070 static constexpr char const * const name{"global_qualification_required"};
29071 static constexpr char const * const typestr{"bool"};
29072 static constexpr bool traverse{false};
29073 static constexpr auto mbr_ptr{&SgTemplateFunctionRefExp::p_global_qualification_required};
29074 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29075 using bind = Desc<SgTemplateFunctionRefExp, bool SgTemplateFunctionRefExp::*, &SgTemplateFunctionRefExp::p_global_qualification_required>;
29076};
29086template <> struct node_from_variant_t<726> { using type = SgTemplateFunctionRefExp; };
29087
29088// Class: TemplateFunctionSymbol
29091 using base = SgFunctionSymbol;
29092 static constexpr char const * const name{"TemplateFunctionSymbol"};
29093 static constexpr unsigned long variant{727};
29094 static constexpr bool concrete{true};
29095 using subclasses_t = mp::List<>;
29096 using fields_t = mp::List<>;
29097};
29098template <> struct node_from_variant_t<727> { using type = SgTemplateFunctionSymbol; };
29099
29100// Class: TemplateMemberFunctionDeclaration
29101template <> struct describe_field_t<SgTemplateMemberFunctionDeclaration,SgTemplateParameterPtrList,&SgTemplateMemberFunctionDeclaration::p_templateParameters> {
29103 using field_type = SgTemplateParameterPtrList;
29104 static constexpr size_t position{0};
29105 static constexpr char const * const name{"templateParameters"};
29106 static constexpr char const * const typestr{"SgTemplateParameterPtrList"};
29107 static constexpr bool traverse{false};
29108 static constexpr auto mbr_ptr{&SgTemplateMemberFunctionDeclaration::p_templateParameters};
29109 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29110 using bind = Desc<SgTemplateMemberFunctionDeclaration, SgTemplateParameterPtrList SgTemplateMemberFunctionDeclaration::*, &SgTemplateMemberFunctionDeclaration::p_templateParameters>;
29111};
29112template <> struct describe_field_t<SgTemplateMemberFunctionDeclaration,SgTemplateArgumentPtrList,&SgTemplateMemberFunctionDeclaration::p_templateSpecializationArguments> {
29114 using field_type = SgTemplateArgumentPtrList;
29115 static constexpr size_t position{1};
29116 static constexpr char const * const name{"templateSpecializationArguments"};
29117 static constexpr char const * const typestr{"SgTemplateArgumentPtrList"};
29118 static constexpr bool traverse{false};
29119 static constexpr auto mbr_ptr{&SgTemplateMemberFunctionDeclaration::p_templateSpecializationArguments};
29120 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29121 using bind = Desc<SgTemplateMemberFunctionDeclaration, SgTemplateArgumentPtrList SgTemplateMemberFunctionDeclaration::*, &SgTemplateMemberFunctionDeclaration::p_templateSpecializationArguments>;
29122};
29123template <> struct describe_field_t<SgTemplateMemberFunctionDeclaration,SgName,&SgTemplateMemberFunctionDeclaration::p_string> {
29125 using field_type = SgName;
29126 static constexpr size_t position{2};
29127 static constexpr char const * const name{"string"};
29128 static constexpr char const * const typestr{"SgName"};
29129 static constexpr bool traverse{false};
29130 static constexpr auto mbr_ptr{&SgTemplateMemberFunctionDeclaration::p_string};
29131 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29132 using bind = Desc<SgTemplateMemberFunctionDeclaration, SgName SgTemplateMemberFunctionDeclaration::*, &SgTemplateMemberFunctionDeclaration::p_string>;
29133};
29134template <> struct describe_field_t<SgTemplateMemberFunctionDeclaration,bool,&SgTemplateMemberFunctionDeclaration::p_string_represents_function_body> {
29136 using field_type = bool;
29137 static constexpr size_t position{3};
29138 static constexpr char const * const name{"string_represents_function_body"};
29139 static constexpr char const * const typestr{"bool"};
29140 static constexpr bool traverse{false};
29141 static constexpr auto mbr_ptr{&SgTemplateMemberFunctionDeclaration::p_string_represents_function_body};
29142 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29143 using bind = Desc<SgTemplateMemberFunctionDeclaration, bool SgTemplateMemberFunctionDeclaration::*, &SgTemplateMemberFunctionDeclaration::p_string_represents_function_body>;
29144};
29145template <> struct describe_field_t<SgTemplateMemberFunctionDeclaration,SgDeclarationScope*,&SgTemplateMemberFunctionDeclaration::p_nonreal_decl_scope> {
29148 static constexpr size_t position{4};
29149 static constexpr char const * const name{"nonreal_decl_scope"};
29150 static constexpr char const * const typestr{"SgDeclarationScope*"};
29151 static constexpr bool traverse{false};
29152 static constexpr auto mbr_ptr{&SgTemplateMemberFunctionDeclaration::p_nonreal_decl_scope};
29153 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29154 using bind = Desc<SgTemplateMemberFunctionDeclaration, SgDeclarationScope* SgTemplateMemberFunctionDeclaration::*, &SgTemplateMemberFunctionDeclaration::p_nonreal_decl_scope>;
29155};
29165template <> struct node_from_variant_t<728> { using type = SgTemplateMemberFunctionDeclaration; };
29166
29167// Class: TemplateMemberFunctionRefExp
29168template <> struct describe_field_t<SgTemplateMemberFunctionRefExp,SgTemplateMemberFunctionSymbol*,&SgTemplateMemberFunctionRefExp::p_symbol_i> {
29171 static constexpr size_t position{0};
29172 static constexpr char const * const name{"symbol_i"};
29173 static constexpr char const * const typestr{"SgTemplateMemberFunctionSymbol*"};
29174 static constexpr bool traverse{false};
29175 static constexpr auto mbr_ptr{&SgTemplateMemberFunctionRefExp::p_symbol_i};
29176 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29177 using bind = Desc<SgTemplateMemberFunctionRefExp, SgTemplateMemberFunctionSymbol* SgTemplateMemberFunctionRefExp::*, &SgTemplateMemberFunctionRefExp::p_symbol_i>;
29178};
29179template <> struct describe_field_t<SgTemplateMemberFunctionRefExp,int,&SgTemplateMemberFunctionRefExp::p_virtual_call> {
29181 using field_type = int;
29182 static constexpr size_t position{1};
29183 static constexpr char const * const name{"virtual_call"};
29184 static constexpr char const * const typestr{"int"};
29185 static constexpr bool traverse{false};
29186 static constexpr auto mbr_ptr{&SgTemplateMemberFunctionRefExp::p_virtual_call};
29187 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29188 using bind = Desc<SgTemplateMemberFunctionRefExp, int SgTemplateMemberFunctionRefExp::*, &SgTemplateMemberFunctionRefExp::p_virtual_call>;
29189};
29190template <> struct describe_field_t<SgTemplateMemberFunctionRefExp,int,&SgTemplateMemberFunctionRefExp::p_need_qualifier> {
29192 using field_type = int;
29193 static constexpr size_t position{2};
29194 static constexpr char const * const name{"need_qualifier"};
29195 static constexpr char const * const typestr{"int"};
29196 static constexpr bool traverse{false};
29197 static constexpr auto mbr_ptr{&SgTemplateMemberFunctionRefExp::p_need_qualifier};
29198 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29199 using bind = Desc<SgTemplateMemberFunctionRefExp, int SgTemplateMemberFunctionRefExp::*, &SgTemplateMemberFunctionRefExp::p_need_qualifier>;
29200};
29201template <> struct describe_field_t<SgTemplateMemberFunctionRefExp,int,&SgTemplateMemberFunctionRefExp::p_name_qualification_length> {
29203 using field_type = int;
29204 static constexpr size_t position{3};
29205 static constexpr char const * const name{"name_qualification_length"};
29206 static constexpr char const * const typestr{"int"};
29207 static constexpr bool traverse{false};
29208 static constexpr auto mbr_ptr{&SgTemplateMemberFunctionRefExp::p_name_qualification_length};
29209 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29210 using bind = Desc<SgTemplateMemberFunctionRefExp, int SgTemplateMemberFunctionRefExp::*, &SgTemplateMemberFunctionRefExp::p_name_qualification_length>;
29211};
29212template <> struct describe_field_t<SgTemplateMemberFunctionRefExp,bool,&SgTemplateMemberFunctionRefExp::p_type_elaboration_required> {
29214 using field_type = bool;
29215 static constexpr size_t position{4};
29216 static constexpr char const * const name{"type_elaboration_required"};
29217 static constexpr char const * const typestr{"bool"};
29218 static constexpr bool traverse{false};
29219 static constexpr auto mbr_ptr{&SgTemplateMemberFunctionRefExp::p_type_elaboration_required};
29220 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29221 using bind = Desc<SgTemplateMemberFunctionRefExp, bool SgTemplateMemberFunctionRefExp::*, &SgTemplateMemberFunctionRefExp::p_type_elaboration_required>;
29222};
29223template <> struct describe_field_t<SgTemplateMemberFunctionRefExp,bool,&SgTemplateMemberFunctionRefExp::p_global_qualification_required> {
29225 using field_type = bool;
29226 static constexpr size_t position{5};
29227 static constexpr char const * const name{"global_qualification_required"};
29228 static constexpr char const * const typestr{"bool"};
29229 static constexpr bool traverse{false};
29230 static constexpr auto mbr_ptr{&SgTemplateMemberFunctionRefExp::p_global_qualification_required};
29231 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29232 using bind = Desc<SgTemplateMemberFunctionRefExp, bool SgTemplateMemberFunctionRefExp::*, &SgTemplateMemberFunctionRefExp::p_global_qualification_required>;
29233};
29243template <> struct node_from_variant_t<729> { using type = SgTemplateMemberFunctionRefExp; };
29244
29245// Class: TemplateMemberFunctionSymbol
29249 static constexpr char const * const name{"TemplateMemberFunctionSymbol"};
29250 static constexpr unsigned long variant{730};
29251 static constexpr bool concrete{true};
29252 using subclasses_t = mp::List<>;
29253 using fields_t = mp::List<>;
29254};
29255template <> struct node_from_variant_t<730> { using type = SgTemplateMemberFunctionSymbol; };
29256
29257// Class: TemplateTypedefDeclaration
29258template <> struct describe_field_t<SgTemplateTypedefDeclaration,SgTemplateParameterPtrList,&SgTemplateTypedefDeclaration::p_templateParameters> {
29260 using field_type = SgTemplateParameterPtrList;
29261 static constexpr size_t position{0};
29262 static constexpr char const * const name{"templateParameters"};
29263 static constexpr char const * const typestr{"SgTemplateParameterPtrList"};
29264 static constexpr bool traverse{false};
29265 static constexpr auto mbr_ptr{&SgTemplateTypedefDeclaration::p_templateParameters};
29266 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29267 using bind = Desc<SgTemplateTypedefDeclaration, SgTemplateParameterPtrList SgTemplateTypedefDeclaration::*, &SgTemplateTypedefDeclaration::p_templateParameters>;
29268};
29269template <> struct describe_field_t<SgTemplateTypedefDeclaration,SgTemplateArgumentPtrList,&SgTemplateTypedefDeclaration::p_templateSpecializationArguments> {
29271 using field_type = SgTemplateArgumentPtrList;
29272 static constexpr size_t position{1};
29273 static constexpr char const * const name{"templateSpecializationArguments"};
29274 static constexpr char const * const typestr{"SgTemplateArgumentPtrList"};
29275 static constexpr bool traverse{false};
29276 static constexpr auto mbr_ptr{&SgTemplateTypedefDeclaration::p_templateSpecializationArguments};
29277 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29278 using bind = Desc<SgTemplateTypedefDeclaration, SgTemplateArgumentPtrList SgTemplateTypedefDeclaration::*, &SgTemplateTypedefDeclaration::p_templateSpecializationArguments>;
29279};
29280template <> struct describe_field_t<SgTemplateTypedefDeclaration,SgName,&SgTemplateTypedefDeclaration::p_string> {
29282 using field_type = SgName;
29283 static constexpr size_t position{2};
29284 static constexpr char const * const name{"string"};
29285 static constexpr char const * const typestr{"SgName"};
29286 static constexpr bool traverse{false};
29287 static constexpr auto mbr_ptr{&SgTemplateTypedefDeclaration::p_string};
29288 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29289 using bind = Desc<SgTemplateTypedefDeclaration, SgName SgTemplateTypedefDeclaration::*, &SgTemplateTypedefDeclaration::p_string>;
29290};
29291template <> struct describe_field_t<SgTemplateTypedefDeclaration,SgDeclarationScope*,&SgTemplateTypedefDeclaration::p_nonreal_decl_scope> {
29294 static constexpr size_t position{3};
29295 static constexpr char const * const name{"nonreal_decl_scope"};
29296 static constexpr char const * const typestr{"SgDeclarationScope*"};
29297 static constexpr bool traverse{false};
29298 static constexpr auto mbr_ptr{&SgTemplateTypedefDeclaration::p_nonreal_decl_scope};
29299 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29300 using bind = Desc<SgTemplateTypedefDeclaration, SgDeclarationScope* SgTemplateTypedefDeclaration::*, &SgTemplateTypedefDeclaration::p_nonreal_decl_scope>;
29301};
29311template <> struct node_from_variant_t<731> { using type = SgTemplateTypedefDeclaration; };
29312
29313// Class: TemplateTypedefSymbol
29316 using base = SgTypedefSymbol;
29317 static constexpr char const * const name{"TemplateTypedefSymbol"};
29318 static constexpr unsigned long variant{732};
29319 static constexpr bool concrete{true};
29320 using subclasses_t = mp::List<>;
29321 using fields_t = mp::List<>;
29322};
29323template <> struct node_from_variant_t<732> { using type = SgTemplateTypedefSymbol; };
29324
29325// Class: TemplateVariableDeclaration
29326template <> struct describe_field_t<SgTemplateVariableDeclaration,SgTemplateParameterPtrList,&SgTemplateVariableDeclaration::p_templateParameters> {
29328 using field_type = SgTemplateParameterPtrList;
29329 static constexpr size_t position{0};
29330 static constexpr char const * const name{"templateParameters"};
29331 static constexpr char const * const typestr{"SgTemplateParameterPtrList"};
29332 static constexpr bool traverse{false};
29333 static constexpr auto mbr_ptr{&SgTemplateVariableDeclaration::p_templateParameters};
29334 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29335 using bind = Desc<SgTemplateVariableDeclaration, SgTemplateParameterPtrList SgTemplateVariableDeclaration::*, &SgTemplateVariableDeclaration::p_templateParameters>;
29336};
29337template <> struct describe_field_t<SgTemplateVariableDeclaration,SgTemplateArgumentPtrList,&SgTemplateVariableDeclaration::p_templateSpecializationArguments> {
29339 using field_type = SgTemplateArgumentPtrList;
29340 static constexpr size_t position{1};
29341 static constexpr char const * const name{"templateSpecializationArguments"};
29342 static constexpr char const * const typestr{"SgTemplateArgumentPtrList"};
29343 static constexpr bool traverse{false};
29344 static constexpr auto mbr_ptr{&SgTemplateVariableDeclaration::p_templateSpecializationArguments};
29345 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29346 using bind = Desc<SgTemplateVariableDeclaration, SgTemplateArgumentPtrList SgTemplateVariableDeclaration::*, &SgTemplateVariableDeclaration::p_templateSpecializationArguments>;
29347};
29348template <> struct describe_field_t<SgTemplateVariableDeclaration,SgName,&SgTemplateVariableDeclaration::p_string> {
29350 using field_type = SgName;
29351 static constexpr size_t position{2};
29352 static constexpr char const * const name{"string"};
29353 static constexpr char const * const typestr{"SgName"};
29354 static constexpr bool traverse{false};
29355 static constexpr auto mbr_ptr{&SgTemplateVariableDeclaration::p_string};
29356 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29357 using bind = Desc<SgTemplateVariableDeclaration, SgName SgTemplateVariableDeclaration::*, &SgTemplateVariableDeclaration::p_string>;
29358};
29359template <> struct describe_field_t<SgTemplateVariableDeclaration,SgDeclarationScope*,&SgTemplateVariableDeclaration::p_nonreal_decl_scope> {
29362 static constexpr size_t position{3};
29363 static constexpr char const * const name{"nonreal_decl_scope"};
29364 static constexpr char const * const typestr{"SgDeclarationScope*"};
29365 static constexpr bool traverse{false};
29366 static constexpr auto mbr_ptr{&SgTemplateVariableDeclaration::p_nonreal_decl_scope};
29367 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29368 using bind = Desc<SgTemplateVariableDeclaration, SgDeclarationScope* SgTemplateVariableDeclaration::*, &SgTemplateVariableDeclaration::p_nonreal_decl_scope>;
29369};
29379template <> struct node_from_variant_t<733> { using type = SgTemplateVariableDeclaration; };
29380
29381// Class: TemplateVariableSymbol
29384 using base = SgVariableSymbol;
29385 static constexpr char const * const name{"TemplateVariableSymbol"};
29386 static constexpr unsigned long variant{734};
29387 static constexpr bool concrete{true};
29388 using subclasses_t = mp::List<>;
29389 using fields_t = mp::List<>;
29390};
29391template <> struct node_from_variant_t<734> { using type = SgTemplateVariableSymbol; };
29392
29393// Class: TemplateClassDefinition
29396 using base = SgClassDefinition;
29397 static constexpr char const * const name{"TemplateClassDefinition"};
29398 static constexpr unsigned long variant{735};
29399 static constexpr bool concrete{true};
29400 using subclasses_t = mp::List<>;
29401 using fields_t = mp::List<>;
29402};
29403template <> struct node_from_variant_t<735> { using type = SgTemplateClassDefinition; };
29404
29405// Class: TemplateFunctionDefinition
29408 using base = SgFunctionDefinition;
29409 static constexpr char const * const name{"TemplateFunctionDefinition"};
29410 static constexpr unsigned long variant{736};
29411 static constexpr bool concrete{true};
29412 using subclasses_t = mp::List<>;
29413 using fields_t = mp::List<>;
29414};
29415template <> struct node_from_variant_t<736> { using type = SgTemplateFunctionDefinition; };
29416
29417// Class: TemplateInstantiationDecl
29420 using field_type = SgName;
29421 static constexpr size_t position{0};
29422 static constexpr char const * const name{"templateName"};
29423 static constexpr char const * const typestr{"SgName"};
29424 static constexpr bool traverse{false};
29425 static constexpr auto mbr_ptr{&SgTemplateInstantiationDecl::p_templateName};
29426 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29427 using bind = Desc<SgTemplateInstantiationDecl, SgName SgTemplateInstantiationDecl::*, &SgTemplateInstantiationDecl::p_templateName>;
29428};
29431 using field_type = SgName;
29432 static constexpr size_t position{1};
29433 static constexpr char const * const name{"templateHeader"};
29434 static constexpr char const * const typestr{"SgName"};
29435 static constexpr bool traverse{false};
29436 static constexpr auto mbr_ptr{&SgTemplateInstantiationDecl::p_templateHeader};
29437 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29438 using bind = Desc<SgTemplateInstantiationDecl, SgName SgTemplateInstantiationDecl::*, &SgTemplateInstantiationDecl::p_templateHeader>;
29439};
29443 static constexpr size_t position{2};
29444 static constexpr char const * const name{"templateDeclaration"};
29445 static constexpr char const * const typestr{"SgTemplateClassDeclaration*"};
29446 static constexpr bool traverse{false};
29447 static constexpr auto mbr_ptr{&SgTemplateInstantiationDecl::p_templateDeclaration};
29448 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29449 using bind = Desc<SgTemplateInstantiationDecl, SgTemplateClassDeclaration* SgTemplateInstantiationDecl::*, &SgTemplateInstantiationDecl::p_templateDeclaration>;
29450};
29453 using field_type = SgTemplateArgumentPtrList;
29454 static constexpr size_t position{3};
29455 static constexpr char const * const name{"templateArguments"};
29456 static constexpr char const * const typestr{"SgTemplateArgumentPtrList"};
29457 static constexpr bool traverse{false};
29458 static constexpr auto mbr_ptr{&SgTemplateInstantiationDecl::p_templateArguments};
29459 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29460 using bind = Desc<SgTemplateInstantiationDecl, SgTemplateArgumentPtrList SgTemplateInstantiationDecl::*, &SgTemplateInstantiationDecl::p_templateArguments>;
29461};
29464 using field_type = bool;
29465 static constexpr size_t position{4};
29466 static constexpr char const * const name{"nameResetFromMangledForm"};
29467 static constexpr char const * const typestr{"bool"};
29468 static constexpr bool traverse{false};
29469 static constexpr auto mbr_ptr{&SgTemplateInstantiationDecl::p_nameResetFromMangledForm};
29470 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29471 using bind = Desc<SgTemplateInstantiationDecl, bool SgTemplateInstantiationDecl::*, &SgTemplateInstantiationDecl::p_nameResetFromMangledForm>;
29472};
29482template <> struct node_from_variant_t<737> { using type = SgTemplateInstantiationDecl; };
29483
29484// Class: TemplateInstantiationDefn
29487 using base = SgClassDefinition;
29488 static constexpr char const * const name{"TemplateInstantiationDefn"};
29489 static constexpr unsigned long variant{738};
29490 static constexpr bool concrete{true};
29491 using subclasses_t = mp::List<>;
29492 using fields_t = mp::List<>;
29493};
29494template <> struct node_from_variant_t<738> { using type = SgTemplateInstantiationDefn; };
29495
29496// Class: TemplateInstantiationDirectiveStatement
29500 static constexpr size_t position{0};
29501 static constexpr char const * const name{"declaration"};
29502 static constexpr char const * const typestr{"SgDeclarationStatement*"};
29503 static constexpr bool traverse{true};
29504 static constexpr auto mbr_ptr{&SgTemplateInstantiationDirectiveStatement::p_declaration};
29505 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29506 using bind = Desc<SgTemplateInstantiationDirectiveStatement, SgDeclarationStatement* SgTemplateInstantiationDirectiveStatement::*, &SgTemplateInstantiationDirectiveStatement::p_declaration>;
29507};
29508template <> struct describe_field_t<SgTemplateInstantiationDirectiveStatement,bool,&SgTemplateInstantiationDirectiveStatement::p_do_not_instantiate> {
29510 using field_type = bool;
29511 static constexpr size_t position{1};
29512 static constexpr char const * const name{"do_not_instantiate"};
29513 static constexpr char const * const typestr{"bool"};
29514 static constexpr bool traverse{false};
29515 static constexpr auto mbr_ptr{&SgTemplateInstantiationDirectiveStatement::p_do_not_instantiate};
29516 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29517 using bind = Desc<SgTemplateInstantiationDirectiveStatement, bool SgTemplateInstantiationDirectiveStatement::*, &SgTemplateInstantiationDirectiveStatement::p_do_not_instantiate>;
29518};
29528template <> struct node_from_variant_t<739> { using type = SgTemplateInstantiationDirectiveStatement; };
29529
29530// Class: TemplateInstantiationFunctionDecl
29533 using field_type = SgName;
29534 static constexpr size_t position{0};
29535 static constexpr char const * const name{"templateName"};
29536 static constexpr char const * const typestr{"SgName"};
29537 static constexpr bool traverse{false};
29538 static constexpr auto mbr_ptr{&SgTemplateInstantiationFunctionDecl::p_templateName};
29539 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29540 using bind = Desc<SgTemplateInstantiationFunctionDecl, SgName SgTemplateInstantiationFunctionDecl::*, &SgTemplateInstantiationFunctionDecl::p_templateName>;
29541};
29545 static constexpr size_t position{1};
29546 static constexpr char const * const name{"templateDeclaration"};
29547 static constexpr char const * const typestr{"SgTemplateFunctionDeclaration*"};
29548 static constexpr bool traverse{false};
29549 static constexpr auto mbr_ptr{&SgTemplateInstantiationFunctionDecl::p_templateDeclaration};
29550 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29551 using bind = Desc<SgTemplateInstantiationFunctionDecl, SgTemplateFunctionDeclaration* SgTemplateInstantiationFunctionDecl::*, &SgTemplateInstantiationFunctionDecl::p_templateDeclaration>;
29552};
29555 using field_type = SgTemplateArgumentPtrList;
29556 static constexpr size_t position{2};
29557 static constexpr char const * const name{"templateArguments"};
29558 static constexpr char const * const typestr{"SgTemplateArgumentPtrList"};
29559 static constexpr bool traverse{false};
29560 static constexpr auto mbr_ptr{&SgTemplateInstantiationFunctionDecl::p_templateArguments};
29561 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29562 using bind = Desc<SgTemplateInstantiationFunctionDecl, SgTemplateArgumentPtrList SgTemplateInstantiationFunctionDecl::*, &SgTemplateInstantiationFunctionDecl::p_templateArguments>;
29563};
29566 using field_type = bool;
29567 static constexpr size_t position{3};
29568 static constexpr char const * const name{"nameResetFromMangledForm"};
29569 static constexpr char const * const typestr{"bool"};
29570 static constexpr bool traverse{false};
29572 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29573 using bind = Desc<SgTemplateInstantiationFunctionDecl, bool SgTemplateInstantiationFunctionDecl::*, &SgTemplateInstantiationFunctionDecl::p_nameResetFromMangledForm>;
29574};
29575template <> struct describe_field_t<SgTemplateInstantiationFunctionDecl,bool,&SgTemplateInstantiationFunctionDecl::p_template_argument_list_is_explicit> {
29577 using field_type = bool;
29578 static constexpr size_t position{4};
29579 static constexpr char const * const name{"template_argument_list_is_explicit"};
29580 static constexpr char const * const typestr{"bool"};
29581 static constexpr bool traverse{false};
29582 static constexpr auto mbr_ptr{&SgTemplateInstantiationFunctionDecl::p_template_argument_list_is_explicit};
29583 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29584 using bind = Desc<SgTemplateInstantiationFunctionDecl, bool SgTemplateInstantiationFunctionDecl::*, &SgTemplateInstantiationFunctionDecl::p_template_argument_list_is_explicit>;
29585};
29595template <> struct node_from_variant_t<740> { using type = SgTemplateInstantiationFunctionDecl; };
29596
29597// Class: TemplateInstantiationMemberFunctionDecl
29600 using field_type = SgName;
29601 static constexpr size_t position{0};
29602 static constexpr char const * const name{"templateName"};
29603 static constexpr char const * const typestr{"SgName"};
29604 static constexpr bool traverse{false};
29605 static constexpr auto mbr_ptr{&SgTemplateInstantiationMemberFunctionDecl::p_templateName};
29606 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29607 using bind = Desc<SgTemplateInstantiationMemberFunctionDecl, SgName SgTemplateInstantiationMemberFunctionDecl::*, &SgTemplateInstantiationMemberFunctionDecl::p_templateName>;
29608};
29612 static constexpr size_t position{1};
29613 static constexpr char const * const name{"templateDeclaration"};
29614 static constexpr char const * const typestr{"SgTemplateMemberFunctionDeclaration*"};
29615 static constexpr bool traverse{false};
29617 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29618 using bind = Desc<SgTemplateInstantiationMemberFunctionDecl, SgTemplateMemberFunctionDeclaration* SgTemplateInstantiationMemberFunctionDecl::*, &SgTemplateInstantiationMemberFunctionDecl::p_templateDeclaration>;
29619};
29622 using field_type = SgTemplateArgumentPtrList;
29623 static constexpr size_t position{2};
29624 static constexpr char const * const name{"templateArguments"};
29625 static constexpr char const * const typestr{"SgTemplateArgumentPtrList"};
29626 static constexpr bool traverse{false};
29628 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29629 using bind = Desc<SgTemplateInstantiationMemberFunctionDecl, SgTemplateArgumentPtrList SgTemplateInstantiationMemberFunctionDecl::*, &SgTemplateInstantiationMemberFunctionDecl::p_templateArguments>;
29630};
29633 using field_type = bool;
29634 static constexpr size_t position{3};
29635 static constexpr char const * const name{"nameResetFromMangledForm"};
29636 static constexpr char const * const typestr{"bool"};
29637 static constexpr bool traverse{false};
29639 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29640 using bind = Desc<SgTemplateInstantiationMemberFunctionDecl, bool SgTemplateInstantiationMemberFunctionDecl::*, &SgTemplateInstantiationMemberFunctionDecl::p_nameResetFromMangledForm>;
29641};
29642template <> struct describe_field_t<SgTemplateInstantiationMemberFunctionDecl,bool,&SgTemplateInstantiationMemberFunctionDecl::p_template_argument_list_is_explicit> {
29644 using field_type = bool;
29645 static constexpr size_t position{4};
29646 static constexpr char const * const name{"template_argument_list_is_explicit"};
29647 static constexpr char const * const typestr{"bool"};
29648 static constexpr bool traverse{false};
29649 static constexpr auto mbr_ptr{&SgTemplateInstantiationMemberFunctionDecl::p_template_argument_list_is_explicit};
29650 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29651 using bind = Desc<SgTemplateInstantiationMemberFunctionDecl, bool SgTemplateInstantiationMemberFunctionDecl::*, &SgTemplateInstantiationMemberFunctionDecl::p_template_argument_list_is_explicit>;
29652};
29662template <> struct node_from_variant_t<741> { using type = SgTemplateInstantiationMemberFunctionDecl; };
29663
29664// Class: TemplateInstantiationTypedefDeclaration
29665template <> struct describe_field_t<SgTemplateInstantiationTypedefDeclaration,SgName,&SgTemplateInstantiationTypedefDeclaration::p_templateName> {
29667 using field_type = SgName;
29668 static constexpr size_t position{0};
29669 static constexpr char const * const name{"templateName"};
29670 static constexpr char const * const typestr{"SgName"};
29671 static constexpr bool traverse{false};
29672 static constexpr auto mbr_ptr{&SgTemplateInstantiationTypedefDeclaration::p_templateName};
29673 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29674 using bind = Desc<SgTemplateInstantiationTypedefDeclaration, SgName SgTemplateInstantiationTypedefDeclaration::*, &SgTemplateInstantiationTypedefDeclaration::p_templateName>;
29675};
29676template <> struct describe_field_t<SgTemplateInstantiationTypedefDeclaration,SgName,&SgTemplateInstantiationTypedefDeclaration::p_templateHeader> {
29678 using field_type = SgName;
29679 static constexpr size_t position{1};
29680 static constexpr char const * const name{"templateHeader"};
29681 static constexpr char const * const typestr{"SgName"};
29682 static constexpr bool traverse{false};
29683 static constexpr auto mbr_ptr{&SgTemplateInstantiationTypedefDeclaration::p_templateHeader};
29684 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29685 using bind = Desc<SgTemplateInstantiationTypedefDeclaration, SgName SgTemplateInstantiationTypedefDeclaration::*, &SgTemplateInstantiationTypedefDeclaration::p_templateHeader>;
29686};
29687template <> struct describe_field_t<SgTemplateInstantiationTypedefDeclaration,SgTemplateTypedefDeclaration*,&SgTemplateInstantiationTypedefDeclaration::p_templateDeclaration> {
29690 static constexpr size_t position{2};
29691 static constexpr char const * const name{"templateDeclaration"};
29692 static constexpr char const * const typestr{"SgTemplateTypedefDeclaration*"};
29693 static constexpr bool traverse{false};
29694 static constexpr auto mbr_ptr{&SgTemplateInstantiationTypedefDeclaration::p_templateDeclaration};
29695 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29696 using bind = Desc<SgTemplateInstantiationTypedefDeclaration, SgTemplateTypedefDeclaration* SgTemplateInstantiationTypedefDeclaration::*, &SgTemplateInstantiationTypedefDeclaration::p_templateDeclaration>;
29697};
29698template <> struct describe_field_t<SgTemplateInstantiationTypedefDeclaration,SgTemplateArgumentPtrList,&SgTemplateInstantiationTypedefDeclaration::p_templateArguments> {
29700 using field_type = SgTemplateArgumentPtrList;
29701 static constexpr size_t position{3};
29702 static constexpr char const * const name{"templateArguments"};
29703 static constexpr char const * const typestr{"SgTemplateArgumentPtrList"};
29704 static constexpr bool traverse{false};
29705 static constexpr auto mbr_ptr{&SgTemplateInstantiationTypedefDeclaration::p_templateArguments};
29706 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29707 using bind = Desc<SgTemplateInstantiationTypedefDeclaration, SgTemplateArgumentPtrList SgTemplateInstantiationTypedefDeclaration::*, &SgTemplateInstantiationTypedefDeclaration::p_templateArguments>;
29708};
29709template <> struct describe_field_t<SgTemplateInstantiationTypedefDeclaration,bool,&SgTemplateInstantiationTypedefDeclaration::p_nameResetFromMangledForm> {
29711 using field_type = bool;
29712 static constexpr size_t position{4};
29713 static constexpr char const * const name{"nameResetFromMangledForm"};
29714 static constexpr char const * const typestr{"bool"};
29715 static constexpr bool traverse{false};
29716 static constexpr auto mbr_ptr{&SgTemplateInstantiationTypedefDeclaration::p_nameResetFromMangledForm};
29717 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29718 using bind = Desc<SgTemplateInstantiationTypedefDeclaration, bool SgTemplateInstantiationTypedefDeclaration::*, &SgTemplateInstantiationTypedefDeclaration::p_nameResetFromMangledForm>;
29719};
29729template <> struct node_from_variant_t<742> { using type = SgTemplateInstantiationTypedefDeclaration; };
29730
29731// Class: TemplateParameter
29732template <> struct describe_field_t<SgTemplateParameter,SgTemplateParameter::template_parameter_enum,&SgTemplateParameter::p_parameterType> {
29735 static constexpr size_t position{0};
29736 static constexpr char const * const name{"parameterType"};
29737 static constexpr char const * const typestr{"SgTemplateParameter::template_parameter_enum"};
29738 static constexpr bool traverse{false};
29739 static constexpr auto mbr_ptr{&SgTemplateParameter::p_parameterType};
29740 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29741 using bind = Desc<SgTemplateParameter, SgTemplateParameter::template_parameter_enum SgTemplateParameter::*, &SgTemplateParameter::p_parameterType>;
29742};
29743template <> struct describe_field_t<SgTemplateParameter,SgType*,&SgTemplateParameter::p_type> {
29745 using field_type = SgType*;
29746 static constexpr size_t position{1};
29747 static constexpr char const * const name{"type"};
29748 static constexpr char const * const typestr{"SgType*"};
29749 static constexpr bool traverse{false};
29750 static constexpr auto mbr_ptr{&SgTemplateParameter::p_type};
29751 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29752 using bind = Desc<SgTemplateParameter, SgType* SgTemplateParameter::*, &SgTemplateParameter::p_type>;
29753};
29754template <> struct describe_field_t<SgTemplateParameter,SgType*,&SgTemplateParameter::p_defaultTypeParameter> {
29756 using field_type = SgType*;
29757 static constexpr size_t position{2};
29758 static constexpr char const * const name{"defaultTypeParameter"};
29759 static constexpr char const * const typestr{"SgType*"};
29760 static constexpr bool traverse{false};
29761 static constexpr auto mbr_ptr{&SgTemplateParameter::p_defaultTypeParameter};
29762 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29763 using bind = Desc<SgTemplateParameter, SgType* SgTemplateParameter::*, &SgTemplateParameter::p_defaultTypeParameter>;
29764};
29765template <> struct describe_field_t<SgTemplateParameter,SgExpression*,&SgTemplateParameter::p_expression> {
29767 using field_type = SgExpression*;
29768 static constexpr size_t position{3};
29769 static constexpr char const * const name{"expression"};
29770 static constexpr char const * const typestr{"SgExpression*"};
29771 static constexpr bool traverse{true};
29772 static constexpr auto mbr_ptr{&SgTemplateParameter::p_expression};
29773 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29774 using bind = Desc<SgTemplateParameter, SgExpression* SgTemplateParameter::*, &SgTemplateParameter::p_expression>;
29775};
29776template <> struct describe_field_t<SgTemplateParameter,SgExpression*,&SgTemplateParameter::p_defaultExpressionParameter> {
29778 using field_type = SgExpression*;
29779 static constexpr size_t position{4};
29780 static constexpr char const * const name{"defaultExpressionParameter"};
29781 static constexpr char const * const typestr{"SgExpression*"};
29782 static constexpr bool traverse{true};
29783 static constexpr auto mbr_ptr{&SgTemplateParameter::p_defaultExpressionParameter};
29784 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29785 using bind = Desc<SgTemplateParameter, SgExpression* SgTemplateParameter::*, &SgTemplateParameter::p_defaultExpressionParameter>;
29786};
29787template <> struct describe_field_t<SgTemplateParameter,SgDeclarationStatement*,&SgTemplateParameter::p_templateDeclaration> {
29790 static constexpr size_t position{5};
29791 static constexpr char const * const name{"templateDeclaration"};
29792 static constexpr char const * const typestr{"SgDeclarationStatement*"};
29793 static constexpr bool traverse{true};
29794 static constexpr auto mbr_ptr{&SgTemplateParameter::p_templateDeclaration};
29795 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29796 using bind = Desc<SgTemplateParameter, SgDeclarationStatement* SgTemplateParameter::*, &SgTemplateParameter::p_templateDeclaration>;
29797};
29798template <> struct describe_field_t<SgTemplateParameter,SgDeclarationStatement*,&SgTemplateParameter::p_defaultTemplateDeclarationParameter> {
29801 static constexpr size_t position{6};
29802 static constexpr char const * const name{"defaultTemplateDeclarationParameter"};
29803 static constexpr char const * const typestr{"SgDeclarationStatement*"};
29804 static constexpr bool traverse{true};
29805 static constexpr auto mbr_ptr{&SgTemplateParameter::p_defaultTemplateDeclarationParameter};
29806 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29807 using bind = Desc<SgTemplateParameter, SgDeclarationStatement* SgTemplateParameter::*, &SgTemplateParameter::p_defaultTemplateDeclarationParameter>;
29808};
29809template <> struct describe_field_t<SgTemplateParameter,SgInitializedName*,&SgTemplateParameter::p_initializedName> {
29812 static constexpr size_t position{7};
29813 static constexpr char const * const name{"initializedName"};
29814 static constexpr char const * const typestr{"SgInitializedName*"};
29815 static constexpr bool traverse{true};
29816 static constexpr auto mbr_ptr{&SgTemplateParameter::p_initializedName};
29817 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29818 using bind = Desc<SgTemplateParameter, SgInitializedName* SgTemplateParameter::*, &SgTemplateParameter::p_initializedName>;
29819};
29829template <> struct node_from_variant_t<743> { using type = SgTemplateParameter; };
29830
29831// Class: TemplateParameterVal
29832template <> struct describe_field_t<SgTemplateParameterVal,int,&SgTemplateParameterVal::p_template_parameter_position> {
29834 using field_type = int;
29835 static constexpr size_t position{0};
29836 static constexpr char const * const name{"template_parameter_position"};
29837 static constexpr char const * const typestr{"int"};
29838 static constexpr bool traverse{false};
29839 static constexpr auto mbr_ptr{&SgTemplateParameterVal::p_template_parameter_position};
29840 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29841 using bind = Desc<SgTemplateParameterVal, int SgTemplateParameterVal::*, &SgTemplateParameterVal::p_template_parameter_position>;
29842};
29843template <> struct describe_field_t<SgTemplateParameterVal,std::string,&SgTemplateParameterVal::p_valueString> {
29845 using field_type = std::string;
29846 static constexpr size_t position{1};
29847 static constexpr char const * const name{"valueString"};
29848 static constexpr char const * const typestr{"std::string"};
29849 static constexpr bool traverse{false};
29850 static constexpr auto mbr_ptr{&SgTemplateParameterVal::p_valueString};
29851 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29852 using bind = Desc<SgTemplateParameterVal, std::string SgTemplateParameterVal::*, &SgTemplateParameterVal::p_valueString>;
29853};
29854template <> struct describe_field_t<SgTemplateParameterVal,SgType*,&SgTemplateParameterVal::p_valueType> {
29856 using field_type = SgType*;
29857 static constexpr size_t position{2};
29858 static constexpr char const * const name{"valueType"};
29859 static constexpr char const * const typestr{"SgType*"};
29860 static constexpr bool traverse{false};
29861 static constexpr auto mbr_ptr{&SgTemplateParameterVal::p_valueType};
29862 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29863 using bind = Desc<SgTemplateParameterVal, SgType* SgTemplateParameterVal::*, &SgTemplateParameterVal::p_valueType>;
29864};
29867 using base = SgValueExp;
29868 static constexpr char const * const name{"TemplateParameterVal"};
29869 static constexpr unsigned long variant{744};
29870 static constexpr bool concrete{true};
29871 using subclasses_t = mp::List<>;
29873};
29874template <> struct node_from_variant_t<744> { using type = SgTemplateParameterVal; };
29875
29876// Class: TemplateParameterList
29877template <> struct describe_field_t<SgTemplateParameterList,SgTemplateParameterPtrList,&SgTemplateParameterList::p_args> {
29879 using field_type = SgTemplateParameterPtrList;
29880 static constexpr size_t position{0};
29881 static constexpr char const * const name{"args"};
29882 static constexpr char const * const typestr{"SgTemplateParameterPtrList"};
29883 static constexpr bool traverse{true};
29884 static constexpr auto mbr_ptr{&SgTemplateParameterList::p_args};
29885 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29886 using bind = Desc<SgTemplateParameterList, SgTemplateParameterPtrList SgTemplateParameterList::*, &SgTemplateParameterList::p_args>;
29887};
29890 using base = SgSupport;
29891 static constexpr char const * const name{"TemplateParameterList"};
29892 static constexpr unsigned long variant{745};
29893 static constexpr bool concrete{true};
29894 using subclasses_t = mp::List<>;
29896};
29897template <> struct node_from_variant_t<745> { using type = SgTemplateParameterList; };
29898
29899// Class: TemplateSymbol
29900template <> struct describe_field_t<SgTemplateSymbol,SgTemplateDeclaration*,&SgTemplateSymbol::p_declaration> {
29901 using parent = SgTemplateSymbol;
29903 static constexpr size_t position{0};
29904 static constexpr char const * const name{"declaration"};
29905 static constexpr char const * const typestr{"SgTemplateDeclaration*"};
29906 static constexpr bool traverse{true};
29907 static constexpr auto mbr_ptr{&SgTemplateSymbol::p_declaration};
29908 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29909 using bind = Desc<SgTemplateSymbol, SgTemplateDeclaration* SgTemplateSymbol::*, &SgTemplateSymbol::p_declaration>;
29910};
29912 using node = SgTemplateSymbol;
29913 using base = SgSymbol;
29914 static constexpr char const * const name{"TemplateSymbol"};
29915 static constexpr unsigned long variant{746};
29916 static constexpr bool concrete{true};
29917 using subclasses_t = mp::List<>;
29919};
29920template <> struct node_from_variant_t<746> { using type = SgTemplateSymbol; };
29921
29922// Class: TemplateType
29923template <> struct describe_field_t<SgTemplateType,SgName,&SgTemplateType::p_name> {
29924 using parent = SgTemplateType;
29925 using field_type = SgName;
29926 static constexpr size_t position{0};
29927 static constexpr char const * const name{"name"};
29928 static constexpr char const * const typestr{"SgName"};
29929 static constexpr bool traverse{false};
29930 static constexpr auto mbr_ptr{&SgTemplateType::p_name};
29931 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29932 using bind = Desc<SgTemplateType, SgName SgTemplateType::*, &SgTemplateType::p_name>;
29933};
29934template <> struct describe_field_t<SgTemplateType,int,&SgTemplateType::p_template_parameter_position> {
29935 using parent = SgTemplateType;
29936 using field_type = int;
29937 static constexpr size_t position{1};
29938 static constexpr char const * const name{"template_parameter_position"};
29939 static constexpr char const * const typestr{"int"};
29940 static constexpr bool traverse{false};
29941 static constexpr auto mbr_ptr{&SgTemplateType::p_template_parameter_position};
29942 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29943 using bind = Desc<SgTemplateType, int SgTemplateType::*, &SgTemplateType::p_template_parameter_position>;
29944};
29945template <> struct describe_field_t<SgTemplateType,int,&SgTemplateType::p_template_parameter_depth> {
29946 using parent = SgTemplateType;
29947 using field_type = int;
29948 static constexpr size_t position{2};
29949 static constexpr char const * const name{"template_parameter_depth"};
29950 static constexpr char const * const typestr{"int"};
29951 static constexpr bool traverse{false};
29952 static constexpr auto mbr_ptr{&SgTemplateType::p_template_parameter_depth};
29953 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29954 using bind = Desc<SgTemplateType, int SgTemplateType::*, &SgTemplateType::p_template_parameter_depth>;
29955};
29956template <> struct describe_field_t<SgTemplateType,SgType *,&SgTemplateType::p_class_type> {
29957 using parent = SgTemplateType;
29958 using field_type = SgType *;
29959 static constexpr size_t position{3};
29960 static constexpr char const * const name{"class_type"};
29961 static constexpr char const * const typestr{"SgType *"};
29962 static constexpr bool traverse{true};
29963 static constexpr auto mbr_ptr{&SgTemplateType::p_class_type};
29964 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29965 using bind = Desc<SgTemplateType, SgType * SgTemplateType::*, &SgTemplateType::p_class_type>;
29966};
29967template <> struct describe_field_t<SgTemplateType,SgType *,&SgTemplateType::p_parent_class_type> {
29968 using parent = SgTemplateType;
29969 using field_type = SgType *;
29970 static constexpr size_t position{4};
29971 static constexpr char const * const name{"parent_class_type"};
29972 static constexpr char const * const typestr{"SgType *"};
29973 static constexpr bool traverse{true};
29974 static constexpr auto mbr_ptr{&SgTemplateType::p_parent_class_type};
29975 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29976 using bind = Desc<SgTemplateType, SgType * SgTemplateType::*, &SgTemplateType::p_parent_class_type>;
29977};
29978template <> struct describe_field_t<SgTemplateType,SgTemplateParameter *,&SgTemplateType::p_template_parameter> {
29979 using parent = SgTemplateType;
29981 static constexpr size_t position{5};
29982 static constexpr char const * const name{"template_parameter"};
29983 static constexpr char const * const typestr{"SgTemplateParameter *"};
29984 static constexpr bool traverse{true};
29985 static constexpr auto mbr_ptr{&SgTemplateType::p_template_parameter};
29986 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29987 using bind = Desc<SgTemplateType, SgTemplateParameter * SgTemplateType::*, &SgTemplateType::p_template_parameter>;
29988};
29989template <> struct describe_field_t<SgTemplateType,SgTemplateArgumentPtrList,&SgTemplateType::p_tpl_args> {
29990 using parent = SgTemplateType;
29991 using field_type = SgTemplateArgumentPtrList;
29992 static constexpr size_t position{6};
29993 static constexpr char const * const name{"tpl_args"};
29994 static constexpr char const * const typestr{"SgTemplateArgumentPtrList"};
29995 static constexpr bool traverse{false};
29996 static constexpr auto mbr_ptr{&SgTemplateType::p_tpl_args};
29997 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29998 using bind = Desc<SgTemplateType, SgTemplateArgumentPtrList SgTemplateType::*, &SgTemplateType::p_tpl_args>;
29999};
30000template <> struct describe_field_t<SgTemplateType,SgTemplateArgumentPtrList,&SgTemplateType::p_part_spec_tpl_args> {
30001 using parent = SgTemplateType;
30002 using field_type = SgTemplateArgumentPtrList;
30003 static constexpr size_t position{7};
30004 static constexpr char const * const name{"part_spec_tpl_args"};
30005 static constexpr char const * const typestr{"SgTemplateArgumentPtrList"};
30006 static constexpr bool traverse{false};
30007 static constexpr auto mbr_ptr{&SgTemplateType::p_part_spec_tpl_args};
30008 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30009 using bind = Desc<SgTemplateType, SgTemplateArgumentPtrList SgTemplateType::*, &SgTemplateType::p_part_spec_tpl_args>;
30010};
30011template <> struct describe_field_t<SgTemplateType,bool,&SgTemplateType::p_packed> {
30012 using parent = SgTemplateType;
30013 using field_type = bool;
30014 static constexpr size_t position{8};
30015 static constexpr char const * const name{"packed"};
30016 static constexpr char const * const typestr{"bool"};
30017 static constexpr bool traverse{false};
30018 static constexpr auto mbr_ptr{&SgTemplateType::p_packed};
30019 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30020 using bind = Desc<SgTemplateType, bool SgTemplateType::*, &SgTemplateType::p_packed>;
30021};
30031template <> struct node_from_variant_t<747> { using type = SgTemplateType; };
30032
30033// Class: ThisExp
30035 using parent = SgThisExp;
30036 using field_type = SgClassSymbol*;
30037 static constexpr size_t position{0};
30038 static constexpr char const * const name{"class_symbol"};
30039 static constexpr char const * const typestr{"SgClassSymbol*"};
30040 static constexpr bool traverse{false};
30041 static constexpr auto mbr_ptr{&SgThisExp::p_class_symbol};
30042 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30043 using bind = Desc<SgThisExp, SgClassSymbol* SgThisExp::*, &SgThisExp::p_class_symbol>;
30044};
30045template <> struct describe_field_t<SgThisExp,SgNonrealSymbol*,&SgThisExp::p_nonreal_symbol> {
30046 using parent = SgThisExp;
30047 using field_type = SgNonrealSymbol*;
30048 static constexpr size_t position{1};
30049 static constexpr char const * const name{"nonreal_symbol"};
30050 static constexpr char const * const typestr{"SgNonrealSymbol*"};
30051 static constexpr bool traverse{false};
30052 static constexpr auto mbr_ptr{&SgThisExp::p_nonreal_symbol};
30053 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30054 using bind = Desc<SgThisExp, SgNonrealSymbol* SgThisExp::*, &SgThisExp::p_nonreal_symbol>;
30055};
30057 using parent = SgThisExp;
30058 using field_type = int;
30059 static constexpr size_t position{2};
30060 static constexpr char const * const name{"pobj_this"};
30061 static constexpr char const * const typestr{"int"};
30062 static constexpr bool traverse{false};
30063 static constexpr auto mbr_ptr{&SgThisExp::p_pobj_this};
30064 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30065 using bind = Desc<SgThisExp, int SgThisExp::*, &SgThisExp::p_pobj_this>;
30066};
30067template <> struct describe_node_t<SgThisExp> {
30068 using node = SgThisExp;
30069 using base = SgExpression;
30070 static constexpr char const * const name{"ThisExp"};
30071 static constexpr unsigned long variant{748};
30072 static constexpr bool concrete{true};
30073 using subclasses_t = mp::List<>;
30075};
30076template <> struct node_from_variant_t<748> { using type = SgThisExp; };
30077
30078// Class: TypeTraitBuiltinOperator
30079template <> struct describe_field_t<SgTypeTraitBuiltinOperator,SgName,&SgTypeTraitBuiltinOperator::p_name> {
30081 using field_type = SgName;
30082 static constexpr size_t position{0};
30083 static constexpr char const * const name{"name"};
30084 static constexpr char const * const typestr{"SgName"};
30085 static constexpr bool traverse{false};
30086 static constexpr auto mbr_ptr{&SgTypeTraitBuiltinOperator::p_name};
30087 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30088 using bind = Desc<SgTypeTraitBuiltinOperator, SgName SgTypeTraitBuiltinOperator::*, &SgTypeTraitBuiltinOperator::p_name>;
30089};
30090template <> struct describe_field_t<SgTypeTraitBuiltinOperator,SgNodePtrList,&SgTypeTraitBuiltinOperator::p_args> {
30092 using field_type = SgNodePtrList;
30093 static constexpr size_t position{1};
30094 static constexpr char const * const name{"args"};
30095 static constexpr char const * const typestr{"SgNodePtrList"};
30096 static constexpr bool traverse{false};
30097 static constexpr auto mbr_ptr{&SgTypeTraitBuiltinOperator::p_args};
30098 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30099 using bind = Desc<SgTypeTraitBuiltinOperator, SgNodePtrList SgTypeTraitBuiltinOperator::*, &SgTypeTraitBuiltinOperator::p_args>;
30100};
30103 using base = SgExpression;
30104 static constexpr char const * const name{"TypeTraitBuiltinOperator"};
30105 static constexpr unsigned long variant{749};
30106 static constexpr bool concrete{true};
30107 using subclasses_t = mp::List<>;
30109};
30110template <> struct node_from_variant_t<749> { using type = SgTypeTraitBuiltinOperator; };
30111
30112// Class: SuperExp
30113template <> struct describe_field_t<SgSuperExp,SgClassSymbol*,&SgSuperExp::p_class_symbol> {
30114 using parent = SgSuperExp;
30115 using field_type = SgClassSymbol*;
30116 static constexpr size_t position{0};
30117 static constexpr char const * const name{"class_symbol"};
30118 static constexpr char const * const typestr{"SgClassSymbol*"};
30119 static constexpr bool traverse{false};
30120 static constexpr auto mbr_ptr{&SgSuperExp::p_class_symbol};
30121 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30122 using bind = Desc<SgSuperExp, SgClassSymbol* SgSuperExp::*, &SgSuperExp::p_class_symbol>;
30123};
30124template <> struct describe_field_t<SgSuperExp,int,&SgSuperExp::p_pobj_super> {
30125 using parent = SgSuperExp;
30126 using field_type = int;
30127 static constexpr size_t position{1};
30128 static constexpr char const * const name{"pobj_super"};
30129 static constexpr char const * const typestr{"int"};
30130 static constexpr bool traverse{false};
30131 static constexpr auto mbr_ptr{&SgSuperExp::p_pobj_super};
30132 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30133 using bind = Desc<SgSuperExp, int SgSuperExp::*, &SgSuperExp::p_pobj_super>;
30134};
30135template <> struct describe_node_t<SgSuperExp> {
30136 using node = SgSuperExp;
30137 using base = SgExpression;
30138 static constexpr char const * const name{"SuperExp"};
30139 static constexpr unsigned long variant{750};
30140 static constexpr bool concrete{true};
30141 using subclasses_t = mp::List<>;
30143};
30144template <> struct node_from_variant_t<750> { using type = SgSuperExp; };
30145
30146// Class: ThrowOp
30148 using parent = SgThrowOp;
30150 static constexpr size_t position{0};
30151 static constexpr char const * const name{"throwKind"};
30152 static constexpr char const * const typestr{"SgThrowOp::e_throw_kind"};
30153 static constexpr bool traverse{false};
30154 static constexpr auto mbr_ptr{&SgThrowOp::p_throwKind};
30155 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30156 using bind = Desc<SgThrowOp, SgThrowOp::e_throw_kind SgThrowOp::*, &SgThrowOp::p_throwKind>;
30157};
30158template <> struct describe_node_t<SgThrowOp> {
30159 using node = SgThrowOp;
30160 using base = SgUnaryOp;
30161 static constexpr char const * const name{"ThrowOp"};
30162 static constexpr unsigned long variant{751};
30163 static constexpr bool concrete{true};
30164 using subclasses_t = mp::List<>;
30166};
30167template <> struct node_from_variant_t<751> { using type = SgThrowOp; };
30168
30169// Class: Token
30170template <> struct describe_field_t<SgToken,std::string,&SgToken::p_lexeme_string> {
30171 using parent = SgToken;
30172 using field_type = std::string;
30173 static constexpr size_t position{0};
30174 static constexpr char const * const name{"lexeme_string"};
30175 static constexpr char const * const typestr{"std::string"};
30176 static constexpr bool traverse{false};
30177 static constexpr auto mbr_ptr{&SgToken::p_lexeme_string};
30178 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30179 using bind = Desc<SgToken, std::string SgToken::*, &SgToken::p_lexeme_string>;
30180};
30181template <> struct describe_field_t<SgToken,unsigned int,&SgToken::p_classification_code> {
30182 using parent = SgToken;
30183 using field_type = unsigned int;
30184 static constexpr size_t position{1};
30185 static constexpr char const * const name{"classification_code"};
30186 static constexpr char const * const typestr{"unsigned int"};
30187 static constexpr bool traverse{false};
30188 static constexpr auto mbr_ptr{&SgToken::p_classification_code};
30189 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30190 using bind = Desc<SgToken, unsigned int SgToken::*, &SgToken::p_classification_code>;
30191};
30192template <> struct describe_node_t<SgToken> {
30193 using node = SgToken;
30194 using base = SgLocatedNode;
30195 static constexpr char const * const name{"Token"};
30196 static constexpr unsigned long variant{752};
30197 static constexpr bool concrete{true};
30198 using subclasses_t = mp::List<>;
30200};
30201template <> struct node_from_variant_t<752> { using type = SgToken; };
30202
30203// Class: TryStmt
30205 using parent = SgTryStmt;
30206 using field_type = SgStatement*;
30207 static constexpr size_t position{0};
30208 static constexpr char const * const name{"body"};
30209 static constexpr char const * const typestr{"SgStatement*"};
30210 static constexpr bool traverse{true};
30211 static constexpr auto mbr_ptr{&SgTryStmt::p_body};
30212 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30213 using bind = Desc<SgTryStmt, SgStatement* SgTryStmt::*, &SgTryStmt::p_body>;
30214};
30216 using parent = SgTryStmt;
30218 static constexpr size_t position{1};
30219 static constexpr char const * const name{"catch_statement_seq_root"};
30220 static constexpr char const * const typestr{"SgCatchStatementSeq*"};
30221 static constexpr bool traverse{true};
30222 static constexpr auto mbr_ptr{&SgTryStmt::p_catch_statement_seq_root};
30223 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30224 using bind = Desc<SgTryStmt, SgCatchStatementSeq* SgTryStmt::*, &SgTryStmt::p_catch_statement_seq_root>;
30225};
30227 using parent = SgTryStmt;
30228 using field_type = SgStatement*;
30229 static constexpr size_t position{2};
30230 static constexpr char const * const name{"else_body"};
30231 static constexpr char const * const typestr{"SgStatement*"};
30232 static constexpr bool traverse{true};
30233 static constexpr auto mbr_ptr{&SgTryStmt::p_else_body};
30234 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30235 using bind = Desc<SgTryStmt, SgStatement* SgTryStmt::*, &SgTryStmt::p_else_body>;
30236};
30238 using parent = SgTryStmt;
30239 using field_type = SgStatement*;
30240 static constexpr size_t position{3};
30241 static constexpr char const * const name{"finally_body"};
30242 static constexpr char const * const typestr{"SgStatement*"};
30243 static constexpr bool traverse{true};
30244 static constexpr auto mbr_ptr{&SgTryStmt::p_finally_body};
30245 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30246 using bind = Desc<SgTryStmt, SgStatement* SgTryStmt::*, &SgTryStmt::p_finally_body>;
30247};
30248template <> struct describe_node_t<SgTryStmt> {
30249 using node = SgTryStmt;
30250 using base = SgStatement;
30251 static constexpr char const * const name{"TryStmt"};
30252 static constexpr unsigned long variant{753};
30253 static constexpr bool concrete{true};
30254 using subclasses_t = mp::List<>;
30256};
30257template <> struct node_from_variant_t<753> { using type = SgTryStmt; };
30258
30259// Class: TupleExp
30260template <> struct describe_node_t<SgTupleExp> {
30261 using node = SgTupleExp;
30262 using base = SgExprListExp;
30263 static constexpr char const * const name{"TupleExp"};
30264 static constexpr unsigned long variant{754};
30265 static constexpr bool concrete{true};
30266 using subclasses_t = mp::List<>;
30267 using fields_t = mp::List<>;
30268};
30269template <> struct node_from_variant_t<754> { using type = SgTupleExp; };
30270
30271// Class: Type
30272template <> struct describe_field_t<SgType,bool,&SgType::p_isCoArray> {
30273 using parent = SgType;
30274 using field_type = bool;
30275 static constexpr size_t position{0};
30276 static constexpr char const * const name{"isCoArray"};
30277 static constexpr char const * const typestr{"bool"};
30278 static constexpr bool traverse{false};
30279 static constexpr auto mbr_ptr{&SgType::p_isCoArray};
30280 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30281 using bind = Desc<SgType, bool SgType::*, &SgType::p_isCoArray>;
30282};
30284 using parent = SgType;
30285 using field_type = int;
30286 static constexpr size_t position{1};
30287 static constexpr char const * const name{"substitutedForTemplateParam"};
30288 static constexpr char const * const typestr{"int"};
30289 static constexpr bool traverse{false};
30290 static constexpr auto mbr_ptr{&SgType::p_substitutedForTemplateParam};
30291 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30292 using bind = Desc<SgType, int SgType::*, &SgType::p_substitutedForTemplateParam>;
30293};
30295 using parent = SgType;
30296 using field_type = SgReferenceType*;
30297 static constexpr size_t position{2};
30298 static constexpr char const * const name{"ref_to"};
30299 static constexpr char const * const typestr{"SgReferenceType*"};
30300 static constexpr bool traverse{false};
30301 static constexpr auto mbr_ptr{&SgType::p_ref_to};
30302 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30303 using bind = Desc<SgType, SgReferenceType* SgType::*, &SgType::p_ref_to>;
30304};
30306 using parent = SgType;
30307 using field_type = SgPointerType*;
30308 static constexpr size_t position{3};
30309 static constexpr char const * const name{"ptr_to"};
30310 static constexpr char const * const typestr{"SgPointerType*"};
30311 static constexpr bool traverse{false};
30312 static constexpr auto mbr_ptr{&SgType::p_ptr_to};
30313 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30314 using bind = Desc<SgType, SgPointerType* SgType::*, &SgType::p_ptr_to>;
30315};
30317 using parent = SgType;
30318 using field_type = SgModifierNodes*;
30319 static constexpr size_t position{4};
30320 static constexpr char const * const name{"modifiers"};
30321 static constexpr char const * const typestr{"SgModifierNodes*"};
30322 static constexpr bool traverse{false};
30323 static constexpr auto mbr_ptr{&SgType::p_modifiers};
30324 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30325 using bind = Desc<SgType, SgModifierNodes* SgType::*, &SgType::p_modifiers>;
30326};
30328 using parent = SgType;
30329 using field_type = SgTypedefSeq*;
30330 static constexpr size_t position{5};
30331 static constexpr char const * const name{"typedefs"};
30332 static constexpr char const * const typestr{"SgTypedefSeq*"};
30333 static constexpr bool traverse{false};
30334 static constexpr auto mbr_ptr{&SgType::p_typedefs};
30335 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30336 using bind = Desc<SgType, SgTypedefSeq* SgType::*, &SgType::p_typedefs>;
30337};
30338template <> struct describe_field_t<SgType,SgRvalueReferenceType*,&SgType::p_rvalue_ref_to> {
30339 using parent = SgType;
30341 static constexpr size_t position{6};
30342 static constexpr char const * const name{"rvalue_ref_to"};
30343 static constexpr char const * const typestr{"SgRvalueReferenceType*"};
30344 static constexpr bool traverse{false};
30345 static constexpr auto mbr_ptr{&SgType::p_rvalue_ref_to};
30346 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30347 using bind = Desc<SgType, SgRvalueReferenceType* SgType::*, &SgType::p_rvalue_ref_to>;
30348};
30349template <> struct describe_field_t<SgType,SgDeclType*,&SgType::p_decltype_ref_to> {
30350 using parent = SgType;
30351 using field_type = SgDeclType*;
30352 static constexpr size_t position{7};
30353 static constexpr char const * const name{"decltype_ref_to"};
30354 static constexpr char const * const typestr{"SgDeclType*"};
30355 static constexpr bool traverse{false};
30356 static constexpr auto mbr_ptr{&SgType::p_decltype_ref_to};
30357 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30358 using bind = Desc<SgType, SgDeclType* SgType::*, &SgType::p_decltype_ref_to>;
30359};
30360template <> struct describe_field_t<SgType,SgTypeOfType*,&SgType::p_typeof_ref_to> {
30361 using parent = SgType;
30362 using field_type = SgTypeOfType*;
30363 static constexpr size_t position{8};
30364 static constexpr char const * const name{"typeof_ref_to"};
30365 static constexpr char const * const typestr{"SgTypeOfType*"};
30366 static constexpr bool traverse{false};
30367 static constexpr auto mbr_ptr{&SgType::p_typeof_ref_to};
30368 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30369 using bind = Desc<SgType, SgTypeOfType* SgType::*, &SgType::p_typeof_ref_to>;
30370};
30371template <> struct describe_field_t<SgType,SgExpression*,&SgType::p_type_kind> {
30372 using parent = SgType;
30373 using field_type = SgExpression*;
30374 static constexpr size_t position{9};
30375 static constexpr char const * const name{"type_kind"};
30376 static constexpr char const * const typestr{"SgExpression*"};
30377 static constexpr bool traverse{true};
30378 static constexpr auto mbr_ptr{&SgType::p_type_kind};
30379 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30380 using bind = Desc<SgType, SgExpression* SgType::*, &SgType::p_type_kind>;
30381};
30382template <> struct describe_field_t<SgType,bool,&SgType::p_hasTypeKindStar> {
30383 using parent = SgType;
30384 using field_type = bool;
30385 static constexpr size_t position{10};
30386 static constexpr char const * const name{"hasTypeKindStar"};
30387 static constexpr char const * const typestr{"bool"};
30388 static constexpr bool traverse{false};
30389 static constexpr auto mbr_ptr{&SgType::p_hasTypeKindStar};
30390 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30391 using bind = Desc<SgType, bool SgType::*, &SgType::p_hasTypeKindStar>;
30392};
30393template <> struct describe_field_t<SgType,AstAttributeMechanism*,&SgType::p_attributeMechanism> {
30394 using parent = SgType;
30396 static constexpr size_t position{11};
30397 static constexpr char const * const name{"attributeMechanism"};
30398 static constexpr char const * const typestr{"AstAttributeMechanism*"};
30399 static constexpr bool traverse{false};
30400 static constexpr auto mbr_ptr{&SgType::p_attributeMechanism};
30401 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30402 using bind = Desc<SgType, AstAttributeMechanism* SgType::*, &SgType::p_attributeMechanism>;
30403};
30404template <> struct describe_node_t<SgType> {
30405 using node = SgType;
30406 using base = SgNode;
30407 static constexpr char const * const name{"Type"};
30408 static constexpr unsigned long variant{755};
30409 static constexpr bool concrete{false};
30412};
30413template <> struct node_from_variant_t<755> { using type = SgType; };
30414
30415// Class: TypeBool
30416template <> struct describe_node_t<SgTypeBool> {
30417 using node = SgTypeBool;
30418 using base = SgType;
30419 static constexpr char const * const name{"TypeBool"};
30420 static constexpr unsigned long variant{756};
30421 static constexpr bool concrete{true};
30422 using subclasses_t = mp::List<>;
30423 using fields_t = mp::List<>;
30424};
30425template <> struct node_from_variant_t<756> { using type = SgTypeBool; };
30426
30427// Class: TypeChar
30428template <> struct describe_node_t<SgTypeChar> {
30429 using node = SgTypeChar;
30430 using base = SgType;
30431 static constexpr char const * const name{"TypeChar"};
30432 static constexpr unsigned long variant{757};
30433 static constexpr bool concrete{true};
30434 using subclasses_t = mp::List<>;
30435 using fields_t = mp::List<>;
30436};
30437template <> struct node_from_variant_t<757> { using type = SgTypeChar; };
30438
30439// Class: TypeChar16
30440template <> struct describe_node_t<SgTypeChar16> {
30441 using node = SgTypeChar16;
30442 using base = SgType;
30443 static constexpr char const * const name{"TypeChar16"};
30444 static constexpr unsigned long variant{758};
30445 static constexpr bool concrete{true};
30446 using subclasses_t = mp::List<>;
30447 using fields_t = mp::List<>;
30448};
30449template <> struct node_from_variant_t<758> { using type = SgTypeChar16; };
30450
30451// Class: TypeChar32
30452template <> struct describe_node_t<SgTypeChar32> {
30453 using node = SgTypeChar32;
30454 using base = SgType;
30455 static constexpr char const * const name{"TypeChar32"};
30456 static constexpr unsigned long variant{759};
30457 static constexpr bool concrete{true};
30458 using subclasses_t = mp::List<>;
30459 using fields_t = mp::List<>;
30460};
30461template <> struct node_from_variant_t<759> { using type = SgTypeChar32; };
30462
30463// Class: TypeComplex
30464template <> struct describe_field_t<SgTypeComplex,SgType*,&SgTypeComplex::p_base_type> {
30465 using parent = SgTypeComplex;
30466 using field_type = SgType*;
30467 static constexpr size_t position{0};
30468 static constexpr char const * const name{"base_type"};
30469 static constexpr char const * const typestr{"SgType*"};
30470 static constexpr bool traverse{false};
30471 static constexpr auto mbr_ptr{&SgTypeComplex::p_base_type};
30472 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30473 using bind = Desc<SgTypeComplex, SgType* SgTypeComplex::*, &SgTypeComplex::p_base_type>;
30474};
30475template <> struct describe_node_t<SgTypeComplex> {
30476 using node = SgTypeComplex;
30477 using base = SgType;
30478 static constexpr char const * const name{"TypeComplex"};
30479 static constexpr unsigned long variant{760};
30480 static constexpr bool concrete{true};
30481 using subclasses_t = mp::List<>;
30483};
30484template <> struct node_from_variant_t<760> { using type = SgTypeComplex; };
30485
30486// Class: TypeDefault
30487template <> struct describe_field_t<SgTypeDefault,SgName,&SgTypeDefault::p_name> {
30488 using parent = SgTypeDefault;
30489 using field_type = SgName;
30490 static constexpr size_t position{0};
30491 static constexpr char const * const name{"name"};
30492 static constexpr char const * const typestr{"SgName"};
30493 static constexpr bool traverse{false};
30494 static constexpr auto mbr_ptr{&SgTypeDefault::p_name};
30495 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30496 using bind = Desc<SgTypeDefault, SgName SgTypeDefault::*, &SgTypeDefault::p_name>;
30497};
30498template <> struct describe_node_t<SgTypeDefault> {
30499 using node = SgTypeDefault;
30500 using base = SgType;
30501 static constexpr char const * const name{"TypeDefault"};
30502 static constexpr unsigned long variant{761};
30503 static constexpr bool concrete{true};
30504 using subclasses_t = mp::List<>;
30506};
30507template <> struct node_from_variant_t<761> { using type = SgTypeDefault; };
30508
30509// Class: TypeExpression
30510template <> struct describe_field_t<SgTypeExpression,SgType*,&SgTypeExpression::p_type> {
30511 using parent = SgTypeExpression;
30512 using field_type = SgType*;
30513 static constexpr size_t position{0};
30514 static constexpr char const * const name{"type"};
30515 static constexpr char const * const typestr{"SgType*"};
30516 static constexpr bool traverse{false};
30517 static constexpr auto mbr_ptr{&SgTypeExpression::p_type};
30518 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30519 using bind = Desc<SgTypeExpression, SgType* SgTypeExpression::*, &SgTypeExpression::p_type>;
30520};
30522 using node = SgTypeExpression;
30523 using base = SgExpression;
30524 static constexpr char const * const name{"TypeExpression"};
30525 static constexpr unsigned long variant{762};
30526 static constexpr bool concrete{true};
30527 using subclasses_t = mp::List<>;
30529};
30530template <> struct node_from_variant_t<762> { using type = SgTypeExpression; };
30531
30532// Class: TypeLabel
30533template <> struct describe_field_t<SgTypeLabel,SgName,&SgTypeLabel::p_name> {
30534 using parent = SgTypeLabel;
30535 using field_type = SgName;
30536 static constexpr size_t position{0};
30537 static constexpr char const * const name{"name"};
30538 static constexpr char const * const typestr{"SgName"};
30539 static constexpr bool traverse{false};
30540 static constexpr auto mbr_ptr{&SgTypeLabel::p_name};
30541 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30542 using bind = Desc<SgTypeLabel, SgName SgTypeLabel::*, &SgTypeLabel::p_name>;
30543};
30544template <> struct describe_node_t<SgTypeLabel> {
30545 using node = SgTypeLabel;
30546 using base = SgType;
30547 static constexpr char const * const name{"TypeLabel"};
30548 static constexpr unsigned long variant{763};
30549 static constexpr bool concrete{true};
30550 using subclasses_t = mp::List<>;
30552};
30553template <> struct node_from_variant_t<763> { using type = SgTypeLabel; };
30554
30555// Class: TypeDouble
30556template <> struct describe_node_t<SgTypeDouble> {
30557 using node = SgTypeDouble;
30558 using base = SgType;
30559 static constexpr char const * const name{"TypeDouble"};
30560 static constexpr unsigned long variant{764};
30561 static constexpr bool concrete{true};
30562 using subclasses_t = mp::List<>;
30563 using fields_t = mp::List<>;
30564};
30565template <> struct node_from_variant_t<764> { using type = SgTypeDouble; };
30566
30567// Class: TypeEllipse
30568template <> struct describe_node_t<SgTypeEllipse> {
30569 using node = SgTypeEllipse;
30570 using base = SgType;
30571 static constexpr char const * const name{"TypeEllipse"};
30572 static constexpr unsigned long variant{765};
30573 static constexpr bool concrete{true};
30574 using subclasses_t = mp::List<>;
30575 using fields_t = mp::List<>;
30576};
30577template <> struct node_from_variant_t<765> { using type = SgTypeEllipse; };
30578
30579// Class: TypeFixed
30580template <> struct describe_field_t<SgTypeFixed,SgExpression*,&SgTypeFixed::p_scale> {
30581 using parent = SgTypeFixed;
30582 using field_type = SgExpression*;
30583 static constexpr size_t position{0};
30584 static constexpr char const * const name{"scale"};
30585 static constexpr char const * const typestr{"SgExpression*"};
30586 static constexpr bool traverse{true};
30587 static constexpr auto mbr_ptr{&SgTypeFixed::p_scale};
30588 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30589 using bind = Desc<SgTypeFixed, SgExpression* SgTypeFixed::*, &SgTypeFixed::p_scale>;
30590};
30591template <> struct describe_field_t<SgTypeFixed,SgExpression*,&SgTypeFixed::p_fraction> {
30592 using parent = SgTypeFixed;
30593 using field_type = SgExpression*;
30594 static constexpr size_t position{1};
30595 static constexpr char const * const name{"fraction"};
30596 static constexpr char const * const typestr{"SgExpression*"};
30597 static constexpr bool traverse{true};
30598 static constexpr auto mbr_ptr{&SgTypeFixed::p_fraction};
30599 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30600 using bind = Desc<SgTypeFixed, SgExpression* SgTypeFixed::*, &SgTypeFixed::p_fraction>;
30601};
30602template <> struct describe_node_t<SgTypeFixed> {
30603 using node = SgTypeFixed;
30604 using base = SgType;
30605 static constexpr char const * const name{"TypeFixed"};
30606 static constexpr unsigned long variant{766};
30607 static constexpr bool concrete{true};
30608 using subclasses_t = mp::List<>;
30610};
30611template <> struct node_from_variant_t<766> { using type = SgTypeFixed; };
30612
30613// Class: TypeFloat
30614template <> struct describe_node_t<SgTypeFloat> {
30615 using node = SgTypeFloat;
30616 using base = SgType;
30617 static constexpr char const * const name{"TypeFloat"};
30618 static constexpr unsigned long variant{767};
30619 static constexpr bool concrete{true};
30620 using subclasses_t = mp::List<>;
30621 using fields_t = mp::List<>;
30622};
30623template <> struct node_from_variant_t<767> { using type = SgTypeFloat; };
30624
30625// Class: TypeFloat128
30626template <> struct describe_node_t<SgTypeFloat128> {
30627 using node = SgTypeFloat128;
30628 using base = SgType;
30629 static constexpr char const * const name{"TypeFloat128"};
30630 static constexpr unsigned long variant{768};
30631 static constexpr bool concrete{true};
30632 using subclasses_t = mp::List<>;
30633 using fields_t = mp::List<>;
30634};
30635template <> struct node_from_variant_t<768> { using type = SgTypeFloat128; };
30636
30637// Class: TypeFloat80
30638template <> struct describe_node_t<SgTypeFloat80> {
30639 using node = SgTypeFloat80;
30640 using base = SgType;
30641 static constexpr char const * const name{"TypeFloat80"};
30642 static constexpr unsigned long variant{769};
30643 static constexpr bool concrete{true};
30644 using subclasses_t = mp::List<>;
30645 using fields_t = mp::List<>;
30646};
30647template <> struct node_from_variant_t<769> { using type = SgTypeFloat80; };
30648
30649// Class: TypeGlobalVoid
30651 using node = SgTypeGlobalVoid;
30652 using base = SgType;
30653 static constexpr char const * const name{"TypeGlobalVoid"};
30654 static constexpr unsigned long variant{770};
30655 static constexpr bool concrete{true};
30656 using subclasses_t = mp::List<>;
30657 using fields_t = mp::List<>;
30658};
30659template <> struct node_from_variant_t<770> { using type = SgTypeGlobalVoid; };
30660
30661// Class: TypeIdOp
30662template <> struct describe_field_t<SgTypeIdOp,SgExpression*,&SgTypeIdOp::p_operand_expr> {
30663 using parent = SgTypeIdOp;
30664 using field_type = SgExpression*;
30665 static constexpr size_t position{0};
30666 static constexpr char const * const name{"operand_expr"};
30667 static constexpr char const * const typestr{"SgExpression*"};
30668 static constexpr bool traverse{true};
30669 static constexpr auto mbr_ptr{&SgTypeIdOp::p_operand_expr};
30670 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30671 using bind = Desc<SgTypeIdOp, SgExpression* SgTypeIdOp::*, &SgTypeIdOp::p_operand_expr>;
30672};
30673template <> struct describe_field_t<SgTypeIdOp,SgType*,&SgTypeIdOp::p_operand_type> {
30674 using parent = SgTypeIdOp;
30675 using field_type = SgType*;
30676 static constexpr size_t position{1};
30677 static constexpr char const * const name{"operand_type"};
30678 static constexpr char const * const typestr{"SgType*"};
30679 static constexpr bool traverse{false};
30680 static constexpr auto mbr_ptr{&SgTypeIdOp::p_operand_type};
30681 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30682 using bind = Desc<SgTypeIdOp, SgType* SgTypeIdOp::*, &SgTypeIdOp::p_operand_type>;
30683};
30684template <> struct describe_field_t<SgTypeIdOp,int,&SgTypeIdOp::p_name_qualification_length> {
30685 using parent = SgTypeIdOp;
30686 using field_type = int;
30687 static constexpr size_t position{2};
30688 static constexpr char const * const name{"name_qualification_length"};
30689 static constexpr char const * const typestr{"int"};
30690 static constexpr bool traverse{false};
30691 static constexpr auto mbr_ptr{&SgTypeIdOp::p_name_qualification_length};
30692 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30693 using bind = Desc<SgTypeIdOp, int SgTypeIdOp::*, &SgTypeIdOp::p_name_qualification_length>;
30694};
30695template <> struct describe_field_t<SgTypeIdOp,bool,&SgTypeIdOp::p_type_elaboration_required> {
30696 using parent = SgTypeIdOp;
30697 using field_type = bool;
30698 static constexpr size_t position{3};
30699 static constexpr char const * const name{"type_elaboration_required"};
30700 static constexpr char const * const typestr{"bool"};
30701 static constexpr bool traverse{false};
30702 static constexpr auto mbr_ptr{&SgTypeIdOp::p_type_elaboration_required};
30703 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30704 using bind = Desc<SgTypeIdOp, bool SgTypeIdOp::*, &SgTypeIdOp::p_type_elaboration_required>;
30705};
30706template <> struct describe_field_t<SgTypeIdOp,bool,&SgTypeIdOp::p_global_qualification_required> {
30707 using parent = SgTypeIdOp;
30708 using field_type = bool;
30709 static constexpr size_t position{4};
30710 static constexpr char const * const name{"global_qualification_required"};
30711 static constexpr char const * const typestr{"bool"};
30712 static constexpr bool traverse{false};
30713 static constexpr auto mbr_ptr{&SgTypeIdOp::p_global_qualification_required};
30714 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30715 using bind = Desc<SgTypeIdOp, bool SgTypeIdOp::*, &SgTypeIdOp::p_global_qualification_required>;
30716};
30717template <> struct describe_field_t<SgTypeIdOp,int,&SgTypeIdOp::p_name_qualification_for_pointer_to_member_class_length> {
30718 using parent = SgTypeIdOp;
30719 using field_type = int;
30720 static constexpr size_t position{5};
30721 static constexpr char const * const name{"name_qualification_for_pointer_to_member_class_length"};
30722 static constexpr char const * const typestr{"int"};
30723 static constexpr bool traverse{false};
30724 static constexpr auto mbr_ptr{&SgTypeIdOp::p_name_qualification_for_pointer_to_member_class_length};
30725 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30726 using bind = Desc<SgTypeIdOp, int SgTypeIdOp::*, &SgTypeIdOp::p_name_qualification_for_pointer_to_member_class_length>;
30727};
30728template <> struct describe_field_t<SgTypeIdOp,bool,&SgTypeIdOp::p_type_elaboration_for_pointer_to_member_class_required> {
30729 using parent = SgTypeIdOp;
30730 using field_type = bool;
30731 static constexpr size_t position{6};
30732 static constexpr char const * const name{"type_elaboration_for_pointer_to_member_class_required"};
30733 static constexpr char const * const typestr{"bool"};
30734 static constexpr bool traverse{false};
30735 static constexpr auto mbr_ptr{&SgTypeIdOp::p_type_elaboration_for_pointer_to_member_class_required};
30736 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30737 using bind = Desc<SgTypeIdOp, bool SgTypeIdOp::*, &SgTypeIdOp::p_type_elaboration_for_pointer_to_member_class_required>;
30738};
30739template <> struct describe_field_t<SgTypeIdOp,bool,&SgTypeIdOp::p_global_qualification_for_pointer_to_member_class_required> {
30740 using parent = SgTypeIdOp;
30741 using field_type = bool;
30742 static constexpr size_t position{7};
30743 static constexpr char const * const name{"global_qualification_for_pointer_to_member_class_required"};
30744 static constexpr char const * const typestr{"bool"};
30745 static constexpr bool traverse{false};
30746 static constexpr auto mbr_ptr{&SgTypeIdOp::p_global_qualification_for_pointer_to_member_class_required};
30747 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30748 using bind = Desc<SgTypeIdOp, bool SgTypeIdOp::*, &SgTypeIdOp::p_global_qualification_for_pointer_to_member_class_required>;
30749};
30759template <> struct node_from_variant_t<771> { using type = SgTypeIdOp; };
30760
30761// Class: TypeImaginary
30762template <> struct describe_field_t<SgTypeImaginary,SgType*,&SgTypeImaginary::p_base_type> {
30763 using parent = SgTypeImaginary;
30764 using field_type = SgType*;
30765 static constexpr size_t position{0};
30766 static constexpr char const * const name{"base_type"};
30767 static constexpr char const * const typestr{"SgType*"};
30768 static constexpr bool traverse{false};
30769 static constexpr auto mbr_ptr{&SgTypeImaginary::p_base_type};
30770 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30771 using bind = Desc<SgTypeImaginary, SgType* SgTypeImaginary::*, &SgTypeImaginary::p_base_type>;
30772};
30774 using node = SgTypeImaginary;
30775 using base = SgType;
30776 static constexpr char const * const name{"TypeImaginary"};
30777 static constexpr unsigned long variant{772};
30778 static constexpr bool concrete{true};
30779 using subclasses_t = mp::List<>;
30781};
30782template <> struct node_from_variant_t<772> { using type = SgTypeImaginary; };
30783
30784// Class: TypeInt
30785template <> struct describe_field_t<SgTypeInt,int,&SgTypeInt::p_field_size> {
30786 using parent = SgTypeInt;
30787 using field_type = int;
30788 static constexpr size_t position{0};
30789 static constexpr char const * const name{"field_size"};
30790 static constexpr char const * const typestr{"int"};
30791 static constexpr bool traverse{false};
30792 static constexpr auto mbr_ptr{&SgTypeInt::p_field_size};
30793 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30794 using bind = Desc<SgTypeInt, int SgTypeInt::*, &SgTypeInt::p_field_size>;
30795};
30796template <> struct describe_node_t<SgTypeInt> {
30797 using node = SgTypeInt;
30798 using base = SgType;
30799 static constexpr char const * const name{"TypeInt"};
30800 static constexpr unsigned long variant{773};
30801 static constexpr bool concrete{true};
30802 using subclasses_t = mp::List<>;
30804};
30805template <> struct node_from_variant_t<773> { using type = SgTypeInt; };
30806
30807// Class: TypeLong
30808template <> struct describe_node_t<SgTypeLong> {
30809 using node = SgTypeLong;
30810 using base = SgType;
30811 static constexpr char const * const name{"TypeLong"};
30812 static constexpr unsigned long variant{774};
30813 static constexpr bool concrete{true};
30814 using subclasses_t = mp::List<>;
30815 using fields_t = mp::List<>;
30816};
30817template <> struct node_from_variant_t<774> { using type = SgTypeLong; };
30818
30819// Class: TypeLongDouble
30821 using node = SgTypeLongDouble;
30822 using base = SgType;
30823 static constexpr char const * const name{"TypeLongDouble"};
30824 static constexpr unsigned long variant{775};
30825 static constexpr bool concrete{true};
30826 using subclasses_t = mp::List<>;
30827 using fields_t = mp::List<>;
30828};
30829template <> struct node_from_variant_t<775> { using type = SgTypeLongDouble; };
30830
30831// Class: TypeLongLong
30832template <> struct describe_node_t<SgTypeLongLong> {
30833 using node = SgTypeLongLong;
30834 using base = SgType;
30835 static constexpr char const * const name{"TypeLongLong"};
30836 static constexpr unsigned long variant{776};
30837 static constexpr bool concrete{true};
30838 using subclasses_t = mp::List<>;
30839 using fields_t = mp::List<>;
30840};
30841template <> struct node_from_variant_t<776> { using type = SgTypeLongLong; };
30842
30843// Class: TypeModifier
30844template <> struct describe_field_t<SgTypeModifier,SgBitVector,&SgTypeModifier::p_modifierVector> {
30845 using parent = SgTypeModifier;
30846 using field_type = SgBitVector;
30847 static constexpr size_t position{0};
30848 static constexpr char const * const name{"modifierVector"};
30849 static constexpr char const * const typestr{"SgBitVector"};
30850 static constexpr bool traverse{false};
30851 static constexpr auto mbr_ptr{&SgTypeModifier::p_modifierVector};
30852 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30853 using bind = Desc<SgTypeModifier, SgBitVector SgTypeModifier::*, &SgTypeModifier::p_modifierVector>;
30854};
30855template <> struct describe_field_t<SgTypeModifier,SgUPC_AccessModifier,&SgTypeModifier::p_upcModifier> {
30856 using parent = SgTypeModifier;
30858 static constexpr size_t position{1};
30859 static constexpr char const * const name{"upcModifier"};
30860 static constexpr char const * const typestr{"SgUPC_AccessModifier"};
30861 static constexpr bool traverse{false};
30862 static constexpr auto mbr_ptr{&SgTypeModifier::p_upcModifier};
30863 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30864 using bind = Desc<SgTypeModifier, SgUPC_AccessModifier SgTypeModifier::*, &SgTypeModifier::p_upcModifier>;
30865};
30866template <> struct describe_field_t<SgTypeModifier,SgStructureModifier,&SgTypeModifier::p_structureModifier> {
30867 using parent = SgTypeModifier;
30869 static constexpr size_t position{2};
30870 static constexpr char const * const name{"structureModifier"};
30871 static constexpr char const * const typestr{"SgStructureModifier"};
30872 static constexpr bool traverse{false};
30873 static constexpr auto mbr_ptr{&SgTypeModifier::p_structureModifier};
30874 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30875 using bind = Desc<SgTypeModifier, SgStructureModifier SgTypeModifier::*, &SgTypeModifier::p_structureModifier>;
30876};
30877template <> struct describe_field_t<SgTypeModifier,SgConstVolatileModifier,&SgTypeModifier::p_constVolatileModifier> {
30878 using parent = SgTypeModifier;
30880 static constexpr size_t position{3};
30881 static constexpr char const * const name{"constVolatileModifier"};
30882 static constexpr char const * const typestr{"SgConstVolatileModifier"};
30883 static constexpr bool traverse{false};
30884 static constexpr auto mbr_ptr{&SgTypeModifier::p_constVolatileModifier};
30885 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30886 using bind = Desc<SgTypeModifier, SgConstVolatileModifier SgTypeModifier::*, &SgTypeModifier::p_constVolatileModifier>;
30887};
30888template <> struct describe_field_t<SgTypeModifier,SgElaboratedTypeModifier,&SgTypeModifier::p_elaboratedTypeModifier> {
30889 using parent = SgTypeModifier;
30891 static constexpr size_t position{4};
30892 static constexpr char const * const name{"elaboratedTypeModifier"};
30893 static constexpr char const * const typestr{"SgElaboratedTypeModifier"};
30894 static constexpr bool traverse{false};
30895 static constexpr auto mbr_ptr{&SgTypeModifier::p_elaboratedTypeModifier};
30896 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30897 using bind = Desc<SgTypeModifier, SgElaboratedTypeModifier SgTypeModifier::*, &SgTypeModifier::p_elaboratedTypeModifier>;
30898};
30899template <> struct describe_field_t<SgTypeModifier,SgTypeModifier::gnu_extension_machine_mode_enum,&SgTypeModifier::p_gnu_extension_machine_mode> {
30900 using parent = SgTypeModifier;
30902 static constexpr size_t position{5};
30903 static constexpr char const * const name{"gnu_extension_machine_mode"};
30904 static constexpr char const * const typestr{"SgTypeModifier::gnu_extension_machine_mode_enum"};
30905 static constexpr bool traverse{false};
30906 static constexpr auto mbr_ptr{&SgTypeModifier::p_gnu_extension_machine_mode};
30907 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30908 using bind = Desc<SgTypeModifier, SgTypeModifier::gnu_extension_machine_mode_enum SgTypeModifier::*, &SgTypeModifier::p_gnu_extension_machine_mode>;
30909};
30910template <> struct describe_field_t<SgTypeModifier,int,&SgTypeModifier::p_gnu_attribute_alignment> {
30911 using parent = SgTypeModifier;
30912 using field_type = int;
30913 static constexpr size_t position{6};
30914 static constexpr char const * const name{"gnu_attribute_alignment"};
30915 static constexpr char const * const typestr{"int"};
30916 static constexpr bool traverse{false};
30917 static constexpr auto mbr_ptr{&SgTypeModifier::p_gnu_attribute_alignment};
30918 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30919 using bind = Desc<SgTypeModifier, int SgTypeModifier::*, &SgTypeModifier::p_gnu_attribute_alignment>;
30920};
30921template <> struct describe_field_t<SgTypeModifier,long,&SgTypeModifier::p_gnu_attribute_sentinel> {
30922 using parent = SgTypeModifier;
30923 using field_type = long;
30924 static constexpr size_t position{7};
30925 static constexpr char const * const name{"gnu_attribute_sentinel"};
30926 static constexpr char const * const typestr{"long"};
30927 static constexpr bool traverse{false};
30928 static constexpr auto mbr_ptr{&SgTypeModifier::p_gnu_attribute_sentinel};
30929 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30930 using bind = Desc<SgTypeModifier, long SgTypeModifier::*, &SgTypeModifier::p_gnu_attribute_sentinel>;
30931};
30932template <> struct describe_field_t<SgTypeModifier,unsigned,&SgTypeModifier::p_address_space_value> {
30933 using parent = SgTypeModifier;
30934 using field_type = unsigned;
30935 static constexpr size_t position{8};
30936 static constexpr char const * const name{"address_space_value"};
30937 static constexpr char const * const typestr{"unsigned"};
30938 static constexpr bool traverse{false};
30939 static constexpr auto mbr_ptr{&SgTypeModifier::p_address_space_value};
30940 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30941 using bind = Desc<SgTypeModifier, unsigned SgTypeModifier::*, &SgTypeModifier::p_address_space_value>;
30942};
30943template <> struct describe_field_t<SgTypeModifier,unsigned,&SgTypeModifier::p_vector_size> {
30944 using parent = SgTypeModifier;
30945 using field_type = unsigned;
30946 static constexpr size_t position{9};
30947 static constexpr char const * const name{"vector_size"};
30948 static constexpr char const * const typestr{"unsigned"};
30949 static constexpr bool traverse{false};
30950 static constexpr auto mbr_ptr{&SgTypeModifier::p_vector_size};
30951 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30952 using bind = Desc<SgTypeModifier, unsigned SgTypeModifier::*, &SgTypeModifier::p_vector_size>;
30953};
30963template <> struct node_from_variant_t<777> { using type = SgTypeModifier; };
30964
30965// Class: TypeMatrix
30966template <> struct describe_field_t<SgTypeMatrix,SgType*,&SgTypeMatrix::p_base_type> {
30967 using parent = SgTypeMatrix;
30968 using field_type = SgType*;
30969 static constexpr size_t position{0};
30970 static constexpr char const * const name{"base_type"};
30971 static constexpr char const * const typestr{"SgType*"};
30972 static constexpr bool traverse{false};
30973 static constexpr auto mbr_ptr{&SgTypeMatrix::p_base_type};
30974 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30975 using bind = Desc<SgTypeMatrix, SgType* SgTypeMatrix::*, &SgTypeMatrix::p_base_type>;
30976};
30977template <> struct describe_node_t<SgTypeMatrix> {
30978 using node = SgTypeMatrix;
30979 using base = SgType;
30980 static constexpr char const * const name{"TypeMatrix"};
30981 static constexpr unsigned long variant{778};
30982 static constexpr bool concrete{true};
30983 using subclasses_t = mp::List<>;
30985};
30986template <> struct node_from_variant_t<778> { using type = SgTypeMatrix; };
30987
30988// Class: TypeTuple
30989template <> struct describe_field_t<SgTypeTuple,SgTypePtrList,&SgTypeTuple::p_types> {
30990 using parent = SgTypeTuple;
30991 using field_type = SgTypePtrList;
30992 static constexpr size_t position{0};
30993 static constexpr char const * const name{"types"};
30994 static constexpr char const * const typestr{"SgTypePtrList"};
30995 static constexpr bool traverse{false};
30996 static constexpr auto mbr_ptr{&SgTypeTuple::p_types};
30997 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
30998 using bind = Desc<SgTypeTuple, SgTypePtrList SgTypeTuple::*, &SgTypeTuple::p_types>;
30999};
31000template <> struct describe_node_t<SgTypeTuple> {
31001 using node = SgTypeTuple;
31002 using base = SgType;
31003 static constexpr char const * const name{"TypeTuple"};
31004 static constexpr unsigned long variant{779};
31005 static constexpr bool concrete{true};
31006 using subclasses_t = mp::List<>;
31008};
31009template <> struct node_from_variant_t<779> { using type = SgTypeTuple; };
31010
31011// Class: TypeNullptr
31012template <> struct describe_node_t<SgTypeNullptr> {
31013 using node = SgTypeNullptr;
31014 using base = SgType;
31015 static constexpr char const * const name{"TypeNullptr"};
31016 static constexpr unsigned long variant{780};
31017 static constexpr bool concrete{true};
31018 using subclasses_t = mp::List<>;
31019 using fields_t = mp::List<>;
31020};
31021template <> struct node_from_variant_t<780> { using type = SgTypeNullptr; };
31022
31023// Class: TypeOfType
31024template <> struct describe_field_t<SgTypeOfType,SgExpression*,&SgTypeOfType::p_base_expression> {
31025 using parent = SgTypeOfType;
31026 using field_type = SgExpression*;
31027 static constexpr size_t position{0};
31028 static constexpr char const * const name{"base_expression"};
31029 static constexpr char const * const typestr{"SgExpression*"};
31030 static constexpr bool traverse{false};
31031 static constexpr auto mbr_ptr{&SgTypeOfType::p_base_expression};
31032 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31033 using bind = Desc<SgTypeOfType, SgExpression* SgTypeOfType::*, &SgTypeOfType::p_base_expression>;
31034};
31035template <> struct describe_field_t<SgTypeOfType,SgType*,&SgTypeOfType::p_base_type> {
31036 using parent = SgTypeOfType;
31037 using field_type = SgType*;
31038 static constexpr size_t position{1};
31039 static constexpr char const * const name{"base_type"};
31040 static constexpr char const * const typestr{"SgType*"};
31041 static constexpr bool traverse{false};
31042 static constexpr auto mbr_ptr{&SgTypeOfType::p_base_type};
31043 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31044 using bind = Desc<SgTypeOfType, SgType* SgTypeOfType::*, &SgTypeOfType::p_base_type>;
31045};
31046template <> struct describe_node_t<SgTypeOfType> {
31047 using node = SgTypeOfType;
31048 using base = SgType;
31049 static constexpr char const * const name{"TypeOfType"};
31050 static constexpr unsigned long variant{781};
31051 static constexpr bool concrete{true};
31052 using subclasses_t = mp::List<>;
31054};
31055template <> struct node_from_variant_t<781> { using type = SgTypeOfType; };
31056
31057// Class: TypeShort
31058template <> struct describe_node_t<SgTypeShort> {
31059 using node = SgTypeShort;
31060 using base = SgType;
31061 static constexpr char const * const name{"TypeShort"};
31062 static constexpr unsigned long variant{782};
31063 static constexpr bool concrete{true};
31064 using subclasses_t = mp::List<>;
31065 using fields_t = mp::List<>;
31066};
31067template <> struct node_from_variant_t<782> { using type = SgTypeShort; };
31068
31069// Class: TypeSigned128bitInteger
31072 using base = SgType;
31073 static constexpr char const * const name{"TypeSigned128bitInteger"};
31074 static constexpr unsigned long variant{783};
31075 static constexpr bool concrete{true};
31076 using subclasses_t = mp::List<>;
31077 using fields_t = mp::List<>;
31078};
31079template <> struct node_from_variant_t<783> { using type = SgTypeSigned128bitInteger; };
31080
31081// Class: TypeSignedChar
31083 using node = SgTypeSignedChar;
31084 using base = SgType;
31085 static constexpr char const * const name{"TypeSignedChar"};
31086 static constexpr unsigned long variant{784};
31087 static constexpr bool concrete{true};
31088 using subclasses_t = mp::List<>;
31089 using fields_t = mp::List<>;
31090};
31091template <> struct node_from_variant_t<784> { using type = SgTypeSignedChar; };
31092
31093// Class: TypeSignedInt
31095 using node = SgTypeSignedInt;
31096 using base = SgType;
31097 static constexpr char const * const name{"TypeSignedInt"};
31098 static constexpr unsigned long variant{785};
31099 static constexpr bool concrete{true};
31100 using subclasses_t = mp::List<>;
31101 using fields_t = mp::List<>;
31102};
31103template <> struct node_from_variant_t<785> { using type = SgTypeSignedInt; };
31104
31105// Class: TypeSignedLong
31107 using node = SgTypeSignedLong;
31108 using base = SgType;
31109 static constexpr char const * const name{"TypeSignedLong"};
31110 static constexpr unsigned long variant{786};
31111 static constexpr bool concrete{true};
31112 using subclasses_t = mp::List<>;
31113 using fields_t = mp::List<>;
31114};
31115template <> struct node_from_variant_t<786> { using type = SgTypeSignedLong; };
31116
31117// Class: TypeSignedLongLong
31119 using node = SgTypeSignedLongLong;
31120 using base = SgType;
31121 static constexpr char const * const name{"TypeSignedLongLong"};
31122 static constexpr unsigned long variant{787};
31123 static constexpr bool concrete{true};
31124 using subclasses_t = mp::List<>;
31125 using fields_t = mp::List<>;
31126};
31127template <> struct node_from_variant_t<787> { using type = SgTypeSignedLongLong; };
31128
31129// Class: TypeSignedShort
31131 using node = SgTypeSignedShort;
31132 using base = SgType;
31133 static constexpr char const * const name{"TypeSignedShort"};
31134 static constexpr unsigned long variant{788};
31135 static constexpr bool concrete{true};
31136 using subclasses_t = mp::List<>;
31137 using fields_t = mp::List<>;
31138};
31139template <> struct node_from_variant_t<788> { using type = SgTypeSignedShort; };
31140
31141// Class: TypeString
31142template <> struct describe_field_t<SgTypeString,SgExpression*,&SgTypeString::p_lengthExpression> {
31143 using parent = SgTypeString;
31144 using field_type = SgExpression*;
31145 static constexpr size_t position{0};
31146 static constexpr char const * const name{"lengthExpression"};
31147 static constexpr char const * const typestr{"SgExpression*"};
31148 static constexpr bool traverse{true};
31149 static constexpr auto mbr_ptr{&SgTypeString::p_lengthExpression};
31150 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31151 using bind = Desc<SgTypeString, SgExpression* SgTypeString::*, &SgTypeString::p_lengthExpression>;
31152};
31153template <> struct describe_node_t<SgTypeString> {
31154 using node = SgTypeString;
31155 using base = SgType;
31156 static constexpr char const * const name{"TypeString"};
31157 static constexpr unsigned long variant{789};
31158 static constexpr bool concrete{true};
31159 using subclasses_t = mp::List<>;
31161};
31162template <> struct node_from_variant_t<789> { using type = SgTypeString; };
31163
31164// Class: TypeUnknown
31165template <> struct describe_field_t<SgTypeUnknown,std::string,&SgTypeUnknown::p_type_name> {
31166 using parent = SgTypeUnknown;
31167 using field_type = std::string;
31168 static constexpr size_t position{0};
31169 static constexpr char const * const name{"type_name"};
31170 static constexpr char const * const typestr{"std::string"};
31171 static constexpr bool traverse{false};
31172 static constexpr auto mbr_ptr{&SgTypeUnknown::p_type_name};
31173 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31174 using bind = Desc<SgTypeUnknown, std::string SgTypeUnknown::*, &SgTypeUnknown::p_type_name>;
31175};
31176template <> struct describe_field_t<SgTypeUnknown,bool,&SgTypeUnknown::p_has_type_name> {
31177 using parent = SgTypeUnknown;
31178 using field_type = bool;
31179 static constexpr size_t position{1};
31180 static constexpr char const * const name{"has_type_name"};
31181 static constexpr char const * const typestr{"bool"};
31182 static constexpr bool traverse{false};
31183 static constexpr auto mbr_ptr{&SgTypeUnknown::p_has_type_name};
31184 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31185 using bind = Desc<SgTypeUnknown, bool SgTypeUnknown::*, &SgTypeUnknown::p_has_type_name>;
31186};
31187template <> struct describe_node_t<SgTypeUnknown> {
31188 using node = SgTypeUnknown;
31189 using base = SgType;
31190 static constexpr char const * const name{"TypeUnknown"};
31191 static constexpr unsigned long variant{790};
31192 static constexpr bool concrete{true};
31193 using subclasses_t = mp::List<>;
31195};
31196template <> struct node_from_variant_t<790> { using type = SgTypeUnknown; };
31197
31198// Class: TypeUnsigned128bitInteger
31201 using base = SgType;
31202 static constexpr char const * const name{"TypeUnsigned128bitInteger"};
31203 static constexpr unsigned long variant{791};
31204 static constexpr bool concrete{true};
31205 using subclasses_t = mp::List<>;
31206 using fields_t = mp::List<>;
31207};
31208template <> struct node_from_variant_t<791> { using type = SgTypeUnsigned128bitInteger; };
31209
31210// Class: TypeUnsignedChar
31212 using node = SgTypeUnsignedChar;
31213 using base = SgType;
31214 static constexpr char const * const name{"TypeUnsignedChar"};
31215 static constexpr unsigned long variant{792};
31216 static constexpr bool concrete{true};
31217 using subclasses_t = mp::List<>;
31218 using fields_t = mp::List<>;
31219};
31220template <> struct node_from_variant_t<792> { using type = SgTypeUnsignedChar; };
31221
31222// Class: TypeUnsignedInt
31224 using node = SgTypeUnsignedInt;
31225 using base = SgType;
31226 static constexpr char const * const name{"TypeUnsignedInt"};
31227 static constexpr unsigned long variant{793};
31228 static constexpr bool concrete{true};
31229 using subclasses_t = mp::List<>;
31230 using fields_t = mp::List<>;
31231};
31232template <> struct node_from_variant_t<793> { using type = SgTypeUnsignedInt; };
31233
31234// Class: TypeUnsignedLong
31236 using node = SgTypeUnsignedLong;
31237 using base = SgType;
31238 static constexpr char const * const name{"TypeUnsignedLong"};
31239 static constexpr unsigned long variant{794};
31240 static constexpr bool concrete{true};
31241 using subclasses_t = mp::List<>;
31242 using fields_t = mp::List<>;
31243};
31244template <> struct node_from_variant_t<794> { using type = SgTypeUnsignedLong; };
31245
31246// Class: TypeUnsignedLongLong
31249 using base = SgType;
31250 static constexpr char const * const name{"TypeUnsignedLongLong"};
31251 static constexpr unsigned long variant{795};
31252 static constexpr bool concrete{true};
31253 using subclasses_t = mp::List<>;
31254 using fields_t = mp::List<>;
31255};
31256template <> struct node_from_variant_t<795> { using type = SgTypeUnsignedLongLong; };
31257
31258// Class: TypeUnsignedShort
31260 using node = SgTypeUnsignedShort;
31261 using base = SgType;
31262 static constexpr char const * const name{"TypeUnsignedShort"};
31263 static constexpr unsigned long variant{796};
31264 static constexpr bool concrete{true};
31265 using subclasses_t = mp::List<>;
31266 using fields_t = mp::List<>;
31267};
31268template <> struct node_from_variant_t<796> { using type = SgTypeUnsignedShort; };
31269
31270// Class: TypeVoid
31271template <> struct describe_node_t<SgTypeVoid> {
31272 using node = SgTypeVoid;
31273 using base = SgType;
31274 static constexpr char const * const name{"TypeVoid"};
31275 static constexpr unsigned long variant{797};
31276 static constexpr bool concrete{true};
31277 using subclasses_t = mp::List<>;
31278 using fields_t = mp::List<>;
31279};
31280template <> struct node_from_variant_t<797> { using type = SgTypeVoid; };
31281
31282// Class: TypeWchar
31283template <> struct describe_node_t<SgTypeWchar> {
31284 using node = SgTypeWchar;
31285 using base = SgType;
31286 static constexpr char const * const name{"TypeWchar"};
31287 static constexpr unsigned long variant{798};
31288 static constexpr bool concrete{true};
31289 using subclasses_t = mp::List<>;
31290 using fields_t = mp::List<>;
31291};
31292template <> struct node_from_variant_t<798> { using type = SgTypeWchar; };
31293
31294// Class: TypedefDeclaration
31297 using field_type = SgName;
31298 static constexpr size_t position{0};
31299 static constexpr char const * const name{"name"};
31300 static constexpr char const * const typestr{"SgName"};
31301 static constexpr bool traverse{false};
31302 static constexpr auto mbr_ptr{&SgTypedefDeclaration::p_name};
31303 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31304 using bind = Desc<SgTypedefDeclaration, SgName SgTypedefDeclaration::*, &SgTypedefDeclaration::p_name>;
31305};
31308 using field_type = SgType*;
31309 static constexpr size_t position{1};
31310 static constexpr char const * const name{"base_type"};
31311 static constexpr char const * const typestr{"SgType*"};
31312 static constexpr bool traverse{false};
31313 static constexpr auto mbr_ptr{&SgTypedefDeclaration::p_base_type};
31314 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31315 using bind = Desc<SgTypedefDeclaration, SgType* SgTypedefDeclaration::*, &SgTypedefDeclaration::p_base_type>;
31316};
31319 using field_type = SgTypedefType*;
31320 static constexpr size_t position{2};
31321 static constexpr char const * const name{"type"};
31322 static constexpr char const * const typestr{"SgTypedefType*"};
31323 static constexpr bool traverse{false};
31324 static constexpr auto mbr_ptr{&SgTypedefDeclaration::p_type};
31325 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31326 using bind = Desc<SgTypedefDeclaration, SgTypedefType* SgTypedefDeclaration::*, &SgTypedefDeclaration::p_type>;
31327};
31331 static constexpr size_t position{3};
31332 static constexpr char const * const name{"declaration"};
31333 static constexpr char const * const typestr{"SgDeclarationStatement*"};
31334 static constexpr bool traverse{true};
31335 static constexpr auto mbr_ptr{&SgTypedefDeclaration::p_declaration};
31336 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31337 using bind = Desc<SgTypedefDeclaration, SgDeclarationStatement* SgTypedefDeclaration::*, &SgTypedefDeclaration::p_declaration>;
31338};
31341 using field_type = SgSymbol*;
31342 static constexpr size_t position{4};
31343 static constexpr char const * const name{"parent_scope"};
31344 static constexpr char const * const typestr{"SgSymbol*"};
31345 static constexpr bool traverse{false};
31346 static constexpr auto mbr_ptr{&SgTypedefDeclaration::p_parent_scope};
31347 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31348 using bind = Desc<SgTypedefDeclaration, SgSymbol* SgTypedefDeclaration::*, &SgTypedefDeclaration::p_parent_scope>;
31349};
31352 using field_type = bool;
31353 static constexpr size_t position{5};
31354 static constexpr char const * const name{"typedefBaseTypeContainsDefiningDeclaration"};
31355 static constexpr char const * const typestr{"bool"};
31356 static constexpr bool traverse{false};
31358 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31359 using bind = Desc<SgTypedefDeclaration, bool SgTypedefDeclaration::*, &SgTypedefDeclaration::p_typedefBaseTypeContainsDefiningDeclaration>;
31360};
31364 static constexpr size_t position{6};
31365 static constexpr char const * const name{"scope"};
31366 static constexpr char const * const typestr{"SgScopeStatement*"};
31367 static constexpr bool traverse{false};
31368 static constexpr auto mbr_ptr{&SgTypedefDeclaration::p_scope};
31369 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31370 using bind = Desc<SgTypedefDeclaration, SgScopeStatement* SgTypedefDeclaration::*, &SgTypedefDeclaration::p_scope>;
31371};
31372template <> struct describe_field_t<SgTypedefDeclaration,bool,&SgTypedefDeclaration::p_requiresGlobalNameQualificationOnType> {
31374 using field_type = bool;
31375 static constexpr size_t position{7};
31376 static constexpr char const * const name{"requiresGlobalNameQualificationOnType"};
31377 static constexpr char const * const typestr{"bool"};
31378 static constexpr bool traverse{false};
31379 static constexpr auto mbr_ptr{&SgTypedefDeclaration::p_requiresGlobalNameQualificationOnType};
31380 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31381 using bind = Desc<SgTypedefDeclaration, bool SgTypedefDeclaration::*, &SgTypedefDeclaration::p_requiresGlobalNameQualificationOnType>;
31382};
31383template <> struct describe_field_t<SgTypedefDeclaration,int,&SgTypedefDeclaration::p_name_qualification_length_for_base_type> {
31385 using field_type = int;
31386 static constexpr size_t position{8};
31387 static constexpr char const * const name{"name_qualification_length_for_base_type"};
31388 static constexpr char const * const typestr{"int"};
31389 static constexpr bool traverse{false};
31390 static constexpr auto mbr_ptr{&SgTypedefDeclaration::p_name_qualification_length_for_base_type};
31391 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31392 using bind = Desc<SgTypedefDeclaration, int SgTypedefDeclaration::*, &SgTypedefDeclaration::p_name_qualification_length_for_base_type>;
31393};
31394template <> struct describe_field_t<SgTypedefDeclaration,bool,&SgTypedefDeclaration::p_type_elaboration_required_for_base_type> {
31396 using field_type = bool;
31397 static constexpr size_t position{9};
31398 static constexpr char const * const name{"type_elaboration_required_for_base_type"};
31399 static constexpr char const * const typestr{"bool"};
31400 static constexpr bool traverse{false};
31401 static constexpr auto mbr_ptr{&SgTypedefDeclaration::p_type_elaboration_required_for_base_type};
31402 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31403 using bind = Desc<SgTypedefDeclaration, bool SgTypedefDeclaration::*, &SgTypedefDeclaration::p_type_elaboration_required_for_base_type>;
31404};
31405template <> struct describe_field_t<SgTypedefDeclaration,bool,&SgTypedefDeclaration::p_global_qualification_required_for_base_type> {
31407 using field_type = bool;
31408 static constexpr size_t position{10};
31409 static constexpr char const * const name{"global_qualification_required_for_base_type"};
31410 static constexpr char const * const typestr{"bool"};
31411 static constexpr bool traverse{false};
31412 static constexpr auto mbr_ptr{&SgTypedefDeclaration::p_global_qualification_required_for_base_type};
31413 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31414 using bind = Desc<SgTypedefDeclaration, bool SgTypedefDeclaration::*, &SgTypedefDeclaration::p_global_qualification_required_for_base_type>;
31415};
31416template <> struct describe_field_t<SgTypedefDeclaration,bool,&SgTypedefDeclaration::p_isAutonomousDeclaration> {
31418 using field_type = bool;
31419 static constexpr size_t position{11};
31420 static constexpr char const * const name{"isAutonomousDeclaration"};
31421 static constexpr char const * const typestr{"bool"};
31422 static constexpr bool traverse{false};
31423 static constexpr auto mbr_ptr{&SgTypedefDeclaration::p_isAutonomousDeclaration};
31424 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31425 using bind = Desc<SgTypedefDeclaration, bool SgTypedefDeclaration::*, &SgTypedefDeclaration::p_isAutonomousDeclaration>;
31426};
31427template <> struct describe_field_t<SgTypedefDeclaration,bool,&SgTypedefDeclaration::p_isAssociatedWithDeclarationList> {
31429 using field_type = bool;
31430 static constexpr size_t position{12};
31431 static constexpr char const * const name{"isAssociatedWithDeclarationList"};
31432 static constexpr char const * const typestr{"bool"};
31433 static constexpr bool traverse{false};
31434 static constexpr auto mbr_ptr{&SgTypedefDeclaration::p_isAssociatedWithDeclarationList};
31435 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31436 using bind = Desc<SgTypedefDeclaration, bool SgTypedefDeclaration::*, &SgTypedefDeclaration::p_isAssociatedWithDeclarationList>;
31437};
31438template <> struct describe_field_t<SgTypedefDeclaration,bool,&SgTypedefDeclaration::p_isFirstDeclarationOfDeclarationList> {
31440 using field_type = bool;
31441 static constexpr size_t position{13};
31442 static constexpr char const * const name{"isFirstDeclarationOfDeclarationList"};
31443 static constexpr char const * const typestr{"bool"};
31444 static constexpr bool traverse{false};
31445 static constexpr auto mbr_ptr{&SgTypedefDeclaration::p_isFirstDeclarationOfDeclarationList};
31446 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31447 using bind = Desc<SgTypedefDeclaration, bool SgTypedefDeclaration::*, &SgTypedefDeclaration::p_isFirstDeclarationOfDeclarationList>;
31448};
31449template <> struct describe_field_t<SgTypedefDeclaration,int,&SgTypedefDeclaration::p_name_qualification_length> {
31451 using field_type = int;
31452 static constexpr size_t position{14};
31453 static constexpr char const * const name{"name_qualification_length"};
31454 static constexpr char const * const typestr{"int"};
31455 static constexpr bool traverse{false};
31456 static constexpr auto mbr_ptr{&SgTypedefDeclaration::p_name_qualification_length};
31457 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31458 using bind = Desc<SgTypedefDeclaration, int SgTypedefDeclaration::*, &SgTypedefDeclaration::p_name_qualification_length>;
31459};
31460template <> struct describe_field_t<SgTypedefDeclaration,bool,&SgTypedefDeclaration::p_type_elaboration_required> {
31462 using field_type = bool;
31463 static constexpr size_t position{15};
31464 static constexpr char const * const name{"type_elaboration_required"};
31465 static constexpr char const * const typestr{"bool"};
31466 static constexpr bool traverse{false};
31467 static constexpr auto mbr_ptr{&SgTypedefDeclaration::p_type_elaboration_required};
31468 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31469 using bind = Desc<SgTypedefDeclaration, bool SgTypedefDeclaration::*, &SgTypedefDeclaration::p_type_elaboration_required>;
31470};
31471template <> struct describe_field_t<SgTypedefDeclaration,bool,&SgTypedefDeclaration::p_global_qualification_required> {
31473 using field_type = bool;
31474 static constexpr size_t position{16};
31475 static constexpr char const * const name{"global_qualification_required"};
31476 static constexpr char const * const typestr{"bool"};
31477 static constexpr bool traverse{false};
31478 static constexpr auto mbr_ptr{&SgTypedefDeclaration::p_global_qualification_required};
31479 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31480 using bind = Desc<SgTypedefDeclaration, bool SgTypedefDeclaration::*, &SgTypedefDeclaration::p_global_qualification_required>;
31481};
31483 using node = SgTypedefDeclaration;
31485 static constexpr char const * const name{"TypedefDeclaration"};
31486 static constexpr unsigned long variant{799};
31487 static constexpr bool concrete{true};
31489 using fields_t = mp::List<describe_field_t<SgTypedefDeclaration,SgName,&SgTypedefDeclaration::p_name>, describe_field_t<SgTypedefDeclaration,SgType*,&SgTypedefDeclaration::p_base_type>, describe_field_t<SgTypedefDeclaration,SgTypedefType*,&SgTypedefDeclaration::p_type>, describe_field_t<SgTypedefDeclaration,SgDeclarationStatement*,&SgTypedefDeclaration::p_declaration>, describe_field_t<SgTypedefDeclaration,SgSymbol*,&SgTypedefDeclaration::p_parent_scope>, describe_field_t<SgTypedefDeclaration,bool,&SgTypedefDeclaration::p_typedefBaseTypeContainsDefiningDeclaration>, describe_field_t<SgTypedefDeclaration,SgScopeStatement*,&SgTypedefDeclaration::p_scope>, describe_field_t<SgTypedefDeclaration,bool,&SgTypedefDeclaration::p_requiresGlobalNameQualificationOnType>, describe_field_t<SgTypedefDeclaration,int,&SgTypedefDeclaration::p_name_qualification_length_for_base_type>, describe_field_t<SgTypedefDeclaration,bool,&SgTypedefDeclaration::p_type_elaboration_required_for_base_type>, describe_field_t<SgTypedefDeclaration,bool,&SgTypedefDeclaration::p_global_qualification_required_for_base_type>, describe_field_t<SgTypedefDeclaration,bool,&SgTypedefDeclaration::p_isAutonomousDeclaration>, describe_field_t<SgTypedefDeclaration,bool,&SgTypedefDeclaration::p_isAssociatedWithDeclarationList>, describe_field_t<SgTypedefDeclaration,bool,&SgTypedefDeclaration::p_isFirstDeclarationOfDeclarationList>, describe_field_t<SgTypedefDeclaration,int,&SgTypedefDeclaration::p_name_qualification_length>, describe_field_t<SgTypedefDeclaration,bool,&SgTypedefDeclaration::p_type_elaboration_required>, describe_field_t<SgTypedefDeclaration,bool,&SgTypedefDeclaration::p_global_qualification_required>>;
31490};
31491template <> struct node_from_variant_t<799> { using type = SgTypedefDeclaration; };
31492
31493// Class: TypedefSeq
31494template <> struct describe_field_t<SgTypedefSeq,SgTypePtrList,&SgTypedefSeq::p_typedefs> {
31495 using parent = SgTypedefSeq;
31496 using field_type = SgTypePtrList;
31497 static constexpr size_t position{0};
31498 static constexpr char const * const name{"typedefs"};
31499 static constexpr char const * const typestr{"SgTypePtrList"};
31500 static constexpr bool traverse{false};
31501 static constexpr auto mbr_ptr{&SgTypedefSeq::p_typedefs};
31502 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31503 using bind = Desc<SgTypedefSeq, SgTypePtrList SgTypedefSeq::*, &SgTypedefSeq::p_typedefs>;
31504};
31505template <> struct describe_node_t<SgTypedefSeq> {
31506 using node = SgTypedefSeq;
31507 using base = SgSupport;
31508 static constexpr char const * const name{"TypedefSeq"};
31509 static constexpr unsigned long variant{800};
31510 static constexpr bool concrete{true};
31511 using subclasses_t = mp::List<>;
31513};
31514template <> struct node_from_variant_t<800> { using type = SgTypedefSeq; };
31515
31516// Class: TypedefSymbol
31517template <> struct describe_field_t<SgTypedefSymbol,SgTypedefDeclaration*,&SgTypedefSymbol::p_declaration> {
31518 using parent = SgTypedefSymbol;
31520 static constexpr size_t position{0};
31521 static constexpr char const * const name{"declaration"};
31522 static constexpr char const * const typestr{"SgTypedefDeclaration*"};
31523 static constexpr bool traverse{true};
31524 static constexpr auto mbr_ptr{&SgTypedefSymbol::p_declaration};
31525 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31526 using bind = Desc<SgTypedefSymbol, SgTypedefDeclaration* SgTypedefSymbol::*, &SgTypedefSymbol::p_declaration>;
31527};
31529 using node = SgTypedefSymbol;
31530 using base = SgTypeSymbol;
31531 static constexpr char const * const name{"TypedefSymbol"};
31532 static constexpr unsigned long variant{801};
31533 static constexpr bool concrete{true};
31536};
31537template <> struct node_from_variant_t<801> { using type = SgTypedefSymbol; };
31538
31539// Class: TypedefType
31540template <> struct describe_field_t<SgTypedefType,SgSymbol*,&SgTypedefType::p_parent_scope> {
31541 using parent = SgTypedefType;
31542 using field_type = SgSymbol*;
31543 static constexpr size_t position{0};
31544 static constexpr char const * const name{"parent_scope"};
31545 static constexpr char const * const typestr{"SgSymbol*"};
31546 static constexpr bool traverse{false};
31547 static constexpr auto mbr_ptr{&SgTypedefType::p_parent_scope};
31548 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31549 using bind = Desc<SgTypedefType, SgSymbol* SgTypedefType::*, &SgTypedefType::p_parent_scope>;
31550};
31551template <> struct describe_node_t<SgTypedefType> {
31552 using node = SgTypedefType;
31553 using base = SgNamedType;
31554 static constexpr char const * const name{"TypedefType"};
31555 static constexpr unsigned long variant{802};
31556 static constexpr bool concrete{true};
31557 using subclasses_t = mp::List<>;
31559};
31560template <> struct node_from_variant_t<802> { using type = SgTypedefType; };
31561
31562// Class: UPC_AccessModifier
31563template <> struct describe_field_t<SgUPC_AccessModifier,SgUPC_AccessModifier::upc_access_modifier_enum,&SgUPC_AccessModifier::p_modifier> {
31566 static constexpr size_t position{0};
31567 static constexpr char const * const name{"modifier"};
31568 static constexpr char const * const typestr{"SgUPC_AccessModifier::upc_access_modifier_enum"};
31569 static constexpr bool traverse{false};
31570 static constexpr auto mbr_ptr{&SgUPC_AccessModifier::p_modifier};
31571 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31572 using bind = Desc<SgUPC_AccessModifier, SgUPC_AccessModifier::upc_access_modifier_enum SgUPC_AccessModifier::*, &SgUPC_AccessModifier::p_modifier>;
31573};
31574template <> struct describe_field_t<SgUPC_AccessModifier,bool,&SgUPC_AccessModifier::p_isShared> {
31576 using field_type = bool;
31577 static constexpr size_t position{1};
31578 static constexpr char const * const name{"isShared"};
31579 static constexpr char const * const typestr{"bool"};
31580 static constexpr bool traverse{false};
31581 static constexpr auto mbr_ptr{&SgUPC_AccessModifier::p_isShared};
31582 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31583 using bind = Desc<SgUPC_AccessModifier, bool SgUPC_AccessModifier::*, &SgUPC_AccessModifier::p_isShared>;
31584};
31585template <> struct describe_field_t<SgUPC_AccessModifier,long,&SgUPC_AccessModifier::p_layout> {
31587 using field_type = long;
31588 static constexpr size_t position{2};
31589 static constexpr char const * const name{"layout"};
31590 static constexpr char const * const typestr{"long"};
31591 static constexpr bool traverse{false};
31592 static constexpr auto mbr_ptr{&SgUPC_AccessModifier::p_layout};
31593 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31594 using bind = Desc<SgUPC_AccessModifier, long SgUPC_AccessModifier::*, &SgUPC_AccessModifier::p_layout>;
31595};
31597 using node = SgUPC_AccessModifier;
31598 using base = SgModifier;
31599 static constexpr char const * const name{"UPC_AccessModifier"};
31600 static constexpr unsigned long variant{803};
31601 static constexpr bool concrete{true};
31602 using subclasses_t = mp::List<>;
31604};
31605template <> struct node_from_variant_t<803> { using type = SgUPC_AccessModifier; };
31606
31607// Class: UnaryAddOp
31608template <> struct describe_node_t<SgUnaryAddOp> {
31609 using node = SgUnaryAddOp;
31610 using base = SgUnaryOp;
31611 static constexpr char const * const name{"UnaryAddOp"};
31612 static constexpr unsigned long variant{804};
31613 static constexpr bool concrete{true};
31614 using subclasses_t = mp::List<>;
31615 using fields_t = mp::List<>;
31616};
31617template <> struct node_from_variant_t<804> { using type = SgUnaryAddOp; };
31618
31619// Class: UnaryOp
31621 using parent = SgUnaryOp;
31622 using field_type = SgExpression*;
31623 static constexpr size_t position{0};
31624 static constexpr char const * const name{"operand_i"};
31625 static constexpr char const * const typestr{"SgExpression*"};
31626 static constexpr bool traverse{true};
31627 static constexpr auto mbr_ptr{&SgUnaryOp::p_operand_i};
31628 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31629 using bind = Desc<SgUnaryOp, SgExpression* SgUnaryOp::*, &SgUnaryOp::p_operand_i>;
31630};
31632 using parent = SgUnaryOp;
31633 using field_type = SgType*;
31634 static constexpr size_t position{1};
31635 static constexpr char const * const name{"expression_type"};
31636 static constexpr char const * const typestr{"SgType*"};
31637 static constexpr bool traverse{false};
31638 static constexpr auto mbr_ptr{&SgUnaryOp::p_expression_type};
31639 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31640 using bind = Desc<SgUnaryOp, SgType* SgUnaryOp::*, &SgUnaryOp::p_expression_type>;
31641};
31643 using parent = SgUnaryOp;
31645 static constexpr size_t position{2};
31646 static constexpr char const * const name{"mode"};
31647 static constexpr char const * const typestr{"SgUnaryOp::Sgop_mode"};
31648 static constexpr bool traverse{false};
31649 static constexpr auto mbr_ptr{&SgUnaryOp::p_mode};
31650 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31651 using bind = Desc<SgUnaryOp, SgUnaryOp::Sgop_mode SgUnaryOp::*, &SgUnaryOp::p_mode>;
31652};
31662template <> struct node_from_variant_t<805> { using type = SgUnaryOp; };
31663
31664// Class: UndefDirectiveStatement
31668 static constexpr char const * const name{"UndefDirectiveStatement"};
31669 static constexpr unsigned long variant{806};
31670 static constexpr bool concrete{true};
31671 using subclasses_t = mp::List<>;
31672 using fields_t = mp::List<>;
31673};
31674template <> struct node_from_variant_t<806> { using type = SgUndefDirectiveStatement; };
31675
31676// Class: UndirectedGraphEdge
31679 using base = SgGraphEdge;
31680 static constexpr char const * const name{"UndirectedGraphEdge"};
31681 static constexpr unsigned long variant{807};
31682 static constexpr bool concrete{true};
31683 using subclasses_t = mp::List<>;
31684 using fields_t = mp::List<>;
31685};
31686template <> struct node_from_variant_t<807> { using type = SgUndirectedGraphEdge; };
31687
31688// Class: UnknownArrayOrFunctionReference
31689template <> struct describe_field_t<SgUnknownArrayOrFunctionReference,std::string,&SgUnknownArrayOrFunctionReference::p_name> {
31691 using field_type = std::string;
31692 static constexpr size_t position{0};
31693 static constexpr char const * const name{"name"};
31694 static constexpr char const * const typestr{"std::string"};
31695 static constexpr bool traverse{false};
31696 static constexpr auto mbr_ptr{&SgUnknownArrayOrFunctionReference::p_name};
31697 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31698 using bind = Desc<SgUnknownArrayOrFunctionReference, std::string SgUnknownArrayOrFunctionReference::*, &SgUnknownArrayOrFunctionReference::p_name>;
31699};
31700template <> struct describe_field_t<SgUnknownArrayOrFunctionReference,SgExpression*,&SgUnknownArrayOrFunctionReference::p_named_reference> {
31702 using field_type = SgExpression*;
31703 static constexpr size_t position{1};
31704 static constexpr char const * const name{"named_reference"};
31705 static constexpr char const * const typestr{"SgExpression*"};
31706 static constexpr bool traverse{true};
31707 static constexpr auto mbr_ptr{&SgUnknownArrayOrFunctionReference::p_named_reference};
31708 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31709 using bind = Desc<SgUnknownArrayOrFunctionReference, SgExpression* SgUnknownArrayOrFunctionReference::*, &SgUnknownArrayOrFunctionReference::p_named_reference>;
31710};
31711template <> struct describe_field_t<SgUnknownArrayOrFunctionReference,SgExprListExp*,&SgUnknownArrayOrFunctionReference::p_expression_list> {
31713 using field_type = SgExprListExp*;
31714 static constexpr size_t position{2};
31715 static constexpr char const * const name{"expression_list"};
31716 static constexpr char const * const typestr{"SgExprListExp*"};
31717 static constexpr bool traverse{true};
31718 static constexpr auto mbr_ptr{&SgUnknownArrayOrFunctionReference::p_expression_list};
31719 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31720 using bind = Desc<SgUnknownArrayOrFunctionReference, SgExprListExp* SgUnknownArrayOrFunctionReference::*, &SgUnknownArrayOrFunctionReference::p_expression_list>;
31721};
31731template <> struct node_from_variant_t<808> { using type = SgUnknownArrayOrFunctionReference; };
31732
31733// Class: UnknownFile
31734template <> struct describe_field_t<SgUnknownFile,SgGlobal*,&SgUnknownFile::p_globalScope> {
31735 using parent = SgUnknownFile;
31736 using field_type = SgGlobal*;
31737 static constexpr size_t position{0};
31738 static constexpr char const * const name{"globalScope"};
31739 static constexpr char const * const typestr{"SgGlobal*"};
31740 static constexpr bool traverse{true};
31741 static constexpr auto mbr_ptr{&SgUnknownFile::p_globalScope};
31742 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31743 using bind = Desc<SgUnknownFile, SgGlobal* SgUnknownFile::*, &SgUnknownFile::p_globalScope>;
31744};
31745template <> struct describe_node_t<SgUnknownFile> {
31746 using node = SgUnknownFile;
31747 using base = SgFile;
31748 static constexpr char const * const name{"UnknownFile"};
31749 static constexpr unsigned long variant{809};
31750 static constexpr bool concrete{true};
31751 using subclasses_t = mp::List<>;
31753};
31754template <> struct node_from_variant_t<809> { using type = SgUnknownFile; };
31755
31756// Class: Unparse_Info
31757template <> struct describe_field_t<SgUnparse_Info,SgBitVector,&SgUnparse_Info::p_unparse_attribute> {
31758 using parent = SgUnparse_Info;
31759 using field_type = SgBitVector;
31760 static constexpr size_t position{0};
31761 static constexpr char const * const name{"unparse_attribute"};
31762 static constexpr char const * const typestr{"SgBitVector"};
31763 static constexpr bool traverse{false};
31764 static constexpr auto mbr_ptr{&SgUnparse_Info::p_unparse_attribute};
31765 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31766 using bind = Desc<SgUnparse_Info, SgBitVector SgUnparse_Info::*, &SgUnparse_Info::p_unparse_attribute>;
31767};
31768template <> struct describe_field_t<SgUnparse_Info,int,&SgUnparse_Info::p_access_attribute> {
31769 using parent = SgUnparse_Info;
31770 using field_type = int;
31771 static constexpr size_t position{1};
31772 static constexpr char const * const name{"access_attribute"};
31773 static constexpr char const * const typestr{"int"};
31774 static constexpr bool traverse{false};
31775 static constexpr auto mbr_ptr{&SgUnparse_Info::p_access_attribute};
31776 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31777 using bind = Desc<SgUnparse_Info, int SgUnparse_Info::*, &SgUnparse_Info::p_access_attribute>;
31778};
31779template <> struct describe_field_t<SgUnparse_Info,int,&SgUnparse_Info::p_nested_expression> {
31780 using parent = SgUnparse_Info;
31781 using field_type = int;
31782 static constexpr size_t position{2};
31783 static constexpr char const * const name{"nested_expression"};
31784 static constexpr char const * const typestr{"int"};
31785 static constexpr bool traverse{false};
31786 static constexpr auto mbr_ptr{&SgUnparse_Info::p_nested_expression};
31787 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31788 using bind = Desc<SgUnparse_Info, int SgUnparse_Info::*, &SgUnparse_Info::p_nested_expression>;
31789};
31790template <> struct describe_field_t<SgUnparse_Info,std::string,&SgUnparse_Info::p_operator_name> {
31791 using parent = SgUnparse_Info;
31792 using field_type = std::string;
31793 static constexpr size_t position{3};
31794 static constexpr char const * const name{"operator_name"};
31795 static constexpr char const * const typestr{"std::string"};
31796 static constexpr bool traverse{false};
31797 static constexpr auto mbr_ptr{&SgUnparse_Info::p_operator_name};
31798 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31799 using bind = Desc<SgUnparse_Info, std::string SgUnparse_Info::*, &SgUnparse_Info::p_operator_name>;
31800};
31801template <> struct describe_field_t<SgUnparse_Info,SgName,&SgUnparse_Info::p_var_name> {
31802 using parent = SgUnparse_Info;
31803 using field_type = SgName;
31804 static constexpr size_t position{4};
31805 static constexpr char const * const name{"var_name"};
31806 static constexpr char const * const typestr{"SgName"};
31807 static constexpr bool traverse{false};
31808 static constexpr auto mbr_ptr{&SgUnparse_Info::p_var_name};
31809 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31810 using bind = Desc<SgUnparse_Info, SgName SgUnparse_Info::*, &SgUnparse_Info::p_var_name>;
31811};
31812template <> struct describe_field_t<SgUnparse_Info,SgDeclarationStatement*,&SgUnparse_Info::p_declstatement_ptr> {
31813 using parent = SgUnparse_Info;
31815 static constexpr size_t position{5};
31816 static constexpr char const * const name{"declstatement_ptr"};
31817 static constexpr char const * const typestr{"SgDeclarationStatement*"};
31818 static constexpr bool traverse{false};
31819 static constexpr auto mbr_ptr{&SgUnparse_Info::p_declstatement_ptr};
31820 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31821 using bind = Desc<SgUnparse_Info, SgDeclarationStatement* SgUnparse_Info::*, &SgUnparse_Info::p_declstatement_ptr>;
31822};
31823template <> struct describe_field_t<SgUnparse_Info,SgDeclarationStatement*,&SgUnparse_Info::p_declaration_of_context> {
31824 using parent = SgUnparse_Info;
31826 static constexpr size_t position{6};
31827 static constexpr char const * const name{"declaration_of_context"};
31828 static constexpr char const * const typestr{"SgDeclarationStatement*"};
31829 static constexpr bool traverse{false};
31830 static constexpr auto mbr_ptr{&SgUnparse_Info::p_declaration_of_context};
31831 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31832 using bind = Desc<SgUnparse_Info, SgDeclarationStatement* SgUnparse_Info::*, &SgUnparse_Info::p_declaration_of_context>;
31833};
31834template <> struct describe_field_t<SgUnparse_Info,SgNamedType*,&SgUnparse_Info::p_current_context> {
31835 using parent = SgUnparse_Info;
31836 using field_type = SgNamedType*;
31837 static constexpr size_t position{7};
31838 static constexpr char const * const name{"current_context"};
31839 static constexpr char const * const typestr{"SgNamedType*"};
31840 static constexpr bool traverse{false};
31841 static constexpr auto mbr_ptr{&SgUnparse_Info::p_current_context};
31842 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31843 using bind = Desc<SgUnparse_Info, SgNamedType* SgUnparse_Info::*, &SgUnparse_Info::p_current_context>;
31844};
31845template <> struct describe_field_t<SgUnparse_Info,SgName,&SgUnparse_Info::p_array_index_list> {
31846 using parent = SgUnparse_Info;
31847 using field_type = SgName;
31848 static constexpr size_t position{8};
31849 static constexpr char const * const name{"array_index_list"};
31850 static constexpr char const * const typestr{"SgName"};
31851 static constexpr bool traverse{false};
31852 static constexpr auto mbr_ptr{&SgUnparse_Info::p_array_index_list};
31853 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31854 using bind = Desc<SgUnparse_Info, SgName SgUnparse_Info::*, &SgUnparse_Info::p_array_index_list>;
31855};
31856template <> struct describe_field_t<SgUnparse_Info,SgNamespaceDeclarationStatement*,&SgUnparse_Info::p_current_namespace> {
31857 using parent = SgUnparse_Info;
31859 static constexpr size_t position{9};
31860 static constexpr char const * const name{"current_namespace"};
31861 static constexpr char const * const typestr{"SgNamespaceDeclarationStatement*"};
31862 static constexpr bool traverse{false};
31863 static constexpr auto mbr_ptr{&SgUnparse_Info::p_current_namespace};
31864 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31865 using bind = Desc<SgUnparse_Info, SgNamespaceDeclarationStatement* SgUnparse_Info::*, &SgUnparse_Info::p_current_namespace>;
31866};
31867template <> struct describe_field_t<SgUnparse_Info,bool,&SgUnparse_Info::p_outputCodeGenerationFormatDelimiters> {
31868 using parent = SgUnparse_Info;
31869 using field_type = bool;
31870 static constexpr size_t position{10};
31871 static constexpr char const * const name{"outputCodeGenerationFormatDelimiters"};
31872 static constexpr char const * const typestr{"bool"};
31873 static constexpr bool traverse{false};
31874 static constexpr auto mbr_ptr{&SgUnparse_Info::p_outputCodeGenerationFormatDelimiters};
31875 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31876 using bind = Desc<SgUnparse_Info, bool SgUnparse_Info::*, &SgUnparse_Info::p_outputCodeGenerationFormatDelimiters>;
31877};
31878template <> struct describe_field_t<SgUnparse_Info,SgQualifiedNamePtrList,&SgUnparse_Info::p_qualifiedNameList> {
31879 using parent = SgUnparse_Info;
31880 using field_type = SgQualifiedNamePtrList;
31881 static constexpr size_t position{11};
31882 static constexpr char const * const name{"qualifiedNameList"};
31883 static constexpr char const * const typestr{"SgQualifiedNamePtrList"};
31884 static constexpr bool traverse{false};
31885 static constexpr auto mbr_ptr{&SgUnparse_Info::p_qualifiedNameList};
31886 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31887 using bind = Desc<SgUnparse_Info, SgQualifiedNamePtrList SgUnparse_Info::*, &SgUnparse_Info::p_qualifiedNameList>;
31888};
31889template <> struct describe_field_t<SgUnparse_Info,SgFunctionCallExp*,&SgUnparse_Info::p_current_function_call> {
31890 using parent = SgUnparse_Info;
31892 static constexpr size_t position{12};
31893 static constexpr char const * const name{"current_function_call"};
31894 static constexpr char const * const typestr{"SgFunctionCallExp*"};
31895 static constexpr bool traverse{false};
31896 static constexpr auto mbr_ptr{&SgUnparse_Info::p_current_function_call};
31897 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31898 using bind = Desc<SgUnparse_Info, SgFunctionCallExp* SgUnparse_Info::*, &SgUnparse_Info::p_current_function_call>;
31899};
31900template <> struct describe_field_t<SgUnparse_Info,SgScopeStatement*,&SgUnparse_Info::p_current_scope> {
31901 using parent = SgUnparse_Info;
31903 static constexpr size_t position{13};
31904 static constexpr char const * const name{"current_scope"};
31905 static constexpr char const * const typestr{"SgScopeStatement*"};
31906 static constexpr bool traverse{false};
31907 static constexpr auto mbr_ptr{&SgUnparse_Info::p_current_scope};
31908 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31909 using bind = Desc<SgUnparse_Info, SgScopeStatement* SgUnparse_Info::*, &SgUnparse_Info::p_current_scope>;
31910};
31911template <> struct describe_field_t<SgUnparse_Info,SgNode*,&SgUnparse_Info::p_reference_node_for_qualification> {
31912 using parent = SgUnparse_Info;
31913 using field_type = SgNode*;
31914 static constexpr size_t position{14};
31915 static constexpr char const * const name{"reference_node_for_qualification"};
31916 static constexpr char const * const typestr{"SgNode*"};
31917 static constexpr bool traverse{false};
31918 static constexpr auto mbr_ptr{&SgUnparse_Info::p_reference_node_for_qualification};
31919 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31920 using bind = Desc<SgUnparse_Info, SgNode* SgUnparse_Info::*, &SgUnparse_Info::p_reference_node_for_qualification>;
31921};
31922template <> struct describe_field_t<SgUnparse_Info,int,&SgUnparse_Info::p_name_qualification_length> {
31923 using parent = SgUnparse_Info;
31924 using field_type = int;
31925 static constexpr size_t position{15};
31926 static constexpr char const * const name{"name_qualification_length"};
31927 static constexpr char const * const typestr{"int"};
31928 static constexpr bool traverse{false};
31929 static constexpr auto mbr_ptr{&SgUnparse_Info::p_name_qualification_length};
31930 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31931 using bind = Desc<SgUnparse_Info, int SgUnparse_Info::*, &SgUnparse_Info::p_name_qualification_length>;
31932};
31933template <> struct describe_field_t<SgUnparse_Info,bool,&SgUnparse_Info::p_type_elaboration_required> {
31934 using parent = SgUnparse_Info;
31935 using field_type = bool;
31936 static constexpr size_t position{16};
31937 static constexpr char const * const name{"type_elaboration_required"};
31938 static constexpr char const * const typestr{"bool"};
31939 static constexpr bool traverse{false};
31940 static constexpr auto mbr_ptr{&SgUnparse_Info::p_type_elaboration_required};
31941 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31942 using bind = Desc<SgUnparse_Info, bool SgUnparse_Info::*, &SgUnparse_Info::p_type_elaboration_required>;
31943};
31944template <> struct describe_field_t<SgUnparse_Info,bool,&SgUnparse_Info::p_global_qualification_required> {
31945 using parent = SgUnparse_Info;
31946 using field_type = bool;
31947 static constexpr size_t position{17};
31948 static constexpr char const * const name{"global_qualification_required"};
31949 static constexpr char const * const typestr{"bool"};
31950 static constexpr bool traverse{false};
31951 static constexpr auto mbr_ptr{&SgUnparse_Info::p_global_qualification_required};
31952 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31953 using bind = Desc<SgUnparse_Info, bool SgUnparse_Info::*, &SgUnparse_Info::p_global_qualification_required>;
31954};
31955template <> struct describe_field_t<SgUnparse_Info,int,&SgUnparse_Info::p_nestingLevel> {
31956 using parent = SgUnparse_Info;
31957 using field_type = int;
31958 static constexpr size_t position{18};
31959 static constexpr char const * const name{"nestingLevel"};
31960 static constexpr char const * const typestr{"int"};
31961 static constexpr bool traverse{false};
31962 static constexpr auto mbr_ptr{&SgUnparse_Info::p_nestingLevel};
31963 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31964 using bind = Desc<SgUnparse_Info, int SgUnparse_Info::*, &SgUnparse_Info::p_nestingLevel>;
31965};
31966template <> struct describe_field_t<SgUnparse_Info,SgFile::languageOption_enum,&SgUnparse_Info::p_language> {
31967 using parent = SgUnparse_Info;
31969 static constexpr size_t position{19};
31970 static constexpr char const * const name{"language"};
31971 static constexpr char const * const typestr{"SgFile::languageOption_enum"};
31972 static constexpr bool traverse{false};
31973 static constexpr auto mbr_ptr{&SgUnparse_Info::p_language};
31974 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31975 using bind = Desc<SgUnparse_Info, SgFile::languageOption_enum SgUnparse_Info::*, &SgUnparse_Info::p_language>;
31976};
31977template <> struct describe_field_t<SgUnparse_Info,SgSourceFile*,&SgUnparse_Info::p_current_source_file> {
31978 using parent = SgUnparse_Info;
31979 using field_type = SgSourceFile*;
31980 static constexpr size_t position{20};
31981 static constexpr char const * const name{"current_source_file"};
31982 static constexpr char const * const typestr{"SgSourceFile*"};
31983 static constexpr bool traverse{false};
31984 static constexpr auto mbr_ptr{&SgUnparse_Info::p_current_source_file};
31985 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31986 using bind = Desc<SgUnparse_Info, SgSourceFile* SgUnparse_Info::*, &SgUnparse_Info::p_current_source_file>;
31987};
31988template <> struct describe_field_t<SgUnparse_Info,bool,&SgUnparse_Info::p_use_generated_name_for_template_arguments> {
31989 using parent = SgUnparse_Info;
31990 using field_type = bool;
31991 static constexpr size_t position{21};
31992 static constexpr char const * const name{"use_generated_name_for_template_arguments"};
31993 static constexpr char const * const typestr{"bool"};
31994 static constexpr bool traverse{false};
31995 static constexpr auto mbr_ptr{&SgUnparse_Info::p_use_generated_name_for_template_arguments};
31996 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31997 using bind = Desc<SgUnparse_Info, bool SgUnparse_Info::*, &SgUnparse_Info::p_use_generated_name_for_template_arguments>;
31998};
31999template <> struct describe_field_t<SgUnparse_Info,bool,&SgUnparse_Info::p_user_defined_literal> {
32000 using parent = SgUnparse_Info;
32001 using field_type = bool;
32002 static constexpr size_t position{22};
32003 static constexpr char const * const name{"user_defined_literal"};
32004 static constexpr char const * const typestr{"bool"};
32005 static constexpr bool traverse{false};
32006 static constexpr auto mbr_ptr{&SgUnparse_Info::p_user_defined_literal};
32007 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32008 using bind = Desc<SgUnparse_Info, bool SgUnparse_Info::*, &SgUnparse_Info::p_user_defined_literal>;
32009};
32010template <> struct describe_field_t<SgUnparse_Info,SgDeclarationStatement*,&SgUnparse_Info::p_declstatement_associated_with_type> {
32011 using parent = SgUnparse_Info;
32013 static constexpr size_t position{23};
32014 static constexpr char const * const name{"declstatement_associated_with_type"};
32015 static constexpr char const * const typestr{"SgDeclarationStatement*"};
32016 static constexpr bool traverse{false};
32017 static constexpr auto mbr_ptr{&SgUnparse_Info::p_declstatement_associated_with_type};
32018 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32019 using bind = Desc<SgUnparse_Info, SgDeclarationStatement* SgUnparse_Info::*, &SgUnparse_Info::p_declstatement_associated_with_type>;
32020};
32021template <> struct describe_field_t<SgUnparse_Info,bool,&SgUnparse_Info::p_context_for_added_parentheses> {
32022 using parent = SgUnparse_Info;
32023 using field_type = bool;
32024 static constexpr size_t position{24};
32025 static constexpr char const * const name{"context_for_added_parentheses"};
32026 static constexpr char const * const typestr{"bool"};
32027 static constexpr bool traverse{false};
32028 static constexpr auto mbr_ptr{&SgUnparse_Info::p_context_for_added_parentheses};
32029 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32030 using bind = Desc<SgUnparse_Info, bool SgUnparse_Info::*, &SgUnparse_Info::p_context_for_added_parentheses>;
32031};
32032template <> struct describe_node_t<SgUnparse_Info> {
32033 using node = SgUnparse_Info;
32034 using base = SgSupport;
32035 static constexpr char const * const name{"Unparse_Info"};
32036 static constexpr unsigned long variant{811};
32037 static constexpr bool concrete{true};
32038 using subclasses_t = mp::List<>;
32039 using fields_t = mp::List<describe_field_t<SgUnparse_Info,SgBitVector,&SgUnparse_Info::p_unparse_attribute>, describe_field_t<SgUnparse_Info,int,&SgUnparse_Info::p_access_attribute>, describe_field_t<SgUnparse_Info,int,&SgUnparse_Info::p_nested_expression>, describe_field_t<SgUnparse_Info,std::string,&SgUnparse_Info::p_operator_name>, describe_field_t<SgUnparse_Info,SgName,&SgUnparse_Info::p_var_name>, describe_field_t<SgUnparse_Info,SgDeclarationStatement*,&SgUnparse_Info::p_declstatement_ptr>, describe_field_t<SgUnparse_Info,SgDeclarationStatement*,&SgUnparse_Info::p_declaration_of_context>, describe_field_t<SgUnparse_Info,SgNamedType*,&SgUnparse_Info::p_current_context>, describe_field_t<SgUnparse_Info,SgName,&SgUnparse_Info::p_array_index_list>, describe_field_t<SgUnparse_Info,SgNamespaceDeclarationStatement*,&SgUnparse_Info::p_current_namespace>, describe_field_t<SgUnparse_Info,bool,&SgUnparse_Info::p_outputCodeGenerationFormatDelimiters>, describe_field_t<SgUnparse_Info,SgQualifiedNamePtrList,&SgUnparse_Info::p_qualifiedNameList>, describe_field_t<SgUnparse_Info,SgFunctionCallExp*,&SgUnparse_Info::p_current_function_call>, describe_field_t<SgUnparse_Info,SgScopeStatement*,&SgUnparse_Info::p_current_scope>, describe_field_t<SgUnparse_Info,SgNode*,&SgUnparse_Info::p_reference_node_for_qualification>, describe_field_t<SgUnparse_Info,int,&SgUnparse_Info::p_name_qualification_length>, describe_field_t<SgUnparse_Info,bool,&SgUnparse_Info::p_type_elaboration_required>, describe_field_t<SgUnparse_Info,bool,&SgUnparse_Info::p_global_qualification_required>, describe_field_t<SgUnparse_Info,int,&SgUnparse_Info::p_nestingLevel>, describe_field_t<SgUnparse_Info,SgFile::languageOption_enum,&SgUnparse_Info::p_language>, describe_field_t<SgUnparse_Info,SgSourceFile*,&SgUnparse_Info::p_current_source_file>, describe_field_t<SgUnparse_Info,bool,&SgUnparse_Info::p_use_generated_name_for_template_arguments>, describe_field_t<SgUnparse_Info,bool,&SgUnparse_Info::p_user_defined_literal>, describe_field_t<SgUnparse_Info,SgDeclarationStatement*,&SgUnparse_Info::p_declstatement_associated_with_type>, describe_field_t<SgUnparse_Info,bool,&SgUnparse_Info::p_context_for_added_parentheses>>;
32040};
32041template <> struct node_from_variant_t<811> { using type = SgUnparse_Info; };
32042
32043// Class: UnsignedCharVal
32044template <> struct describe_field_t<SgUnsignedCharVal,unsigned char,&SgUnsignedCharVal::p_value> {
32045 using parent = SgUnsignedCharVal;
32046 using field_type = unsigned char;
32047 static constexpr size_t position{0};
32048 static constexpr char const * const name{"value"};
32049 static constexpr char const * const typestr{"unsigned char"};
32050 static constexpr bool traverse{false};
32051 static constexpr auto mbr_ptr{&SgUnsignedCharVal::p_value};
32052 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32053 using bind = Desc<SgUnsignedCharVal, unsigned char SgUnsignedCharVal::*, &SgUnsignedCharVal::p_value>;
32054};
32055template <> struct describe_field_t<SgUnsignedCharVal,std::string,&SgUnsignedCharVal::p_valueString> {
32056 using parent = SgUnsignedCharVal;
32057 using field_type = std::string;
32058 static constexpr size_t position{1};
32059 static constexpr char const * const name{"valueString"};
32060 static constexpr char const * const typestr{"std::string"};
32061 static constexpr bool traverse{false};
32062 static constexpr auto mbr_ptr{&SgUnsignedCharVal::p_valueString};
32063 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32064 using bind = Desc<SgUnsignedCharVal, std::string SgUnsignedCharVal::*, &SgUnsignedCharVal::p_valueString>;
32065};
32067 using node = SgUnsignedCharVal;
32068 using base = SgValueExp;
32069 static constexpr char const * const name{"UnsignedCharVal"};
32070 static constexpr unsigned long variant{812};
32071 static constexpr bool concrete{true};
32072 using subclasses_t = mp::List<>;
32074};
32075template <> struct node_from_variant_t<812> { using type = SgUnsignedCharVal; };
32076
32077// Class: UnsignedIntVal
32078template <> struct describe_field_t<SgUnsignedIntVal,unsigned int,&SgUnsignedIntVal::p_value> {
32079 using parent = SgUnsignedIntVal;
32080 using field_type = unsigned int;
32081 static constexpr size_t position{0};
32082 static constexpr char const * const name{"value"};
32083 static constexpr char const * const typestr{"unsigned int"};
32084 static constexpr bool traverse{false};
32085 static constexpr auto mbr_ptr{&SgUnsignedIntVal::p_value};
32086 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32087 using bind = Desc<SgUnsignedIntVal, unsigned int SgUnsignedIntVal::*, &SgUnsignedIntVal::p_value>;
32088};
32089template <> struct describe_field_t<SgUnsignedIntVal,std::string,&SgUnsignedIntVal::p_valueString> {
32090 using parent = SgUnsignedIntVal;
32091 using field_type = std::string;
32092 static constexpr size_t position{1};
32093 static constexpr char const * const name{"valueString"};
32094 static constexpr char const * const typestr{"std::string"};
32095 static constexpr bool traverse{false};
32096 static constexpr auto mbr_ptr{&SgUnsignedIntVal::p_valueString};
32097 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32098 using bind = Desc<SgUnsignedIntVal, std::string SgUnsignedIntVal::*, &SgUnsignedIntVal::p_valueString>;
32099};
32101 using node = SgUnsignedIntVal;
32102 using base = SgValueExp;
32103 static constexpr char const * const name{"UnsignedIntVal"};
32104 static constexpr unsigned long variant{813};
32105 static constexpr bool concrete{true};
32106 using subclasses_t = mp::List<>;
32108};
32109template <> struct node_from_variant_t<813> { using type = SgUnsignedIntVal; };
32110
32111// Class: UnsignedLongLongIntVal
32112template <> struct describe_field_t<SgUnsignedLongLongIntVal,unsigned long long int,&SgUnsignedLongLongIntVal::p_value> {
32114 using field_type = unsigned long long int;
32115 static constexpr size_t position{0};
32116 static constexpr char const * const name{"value"};
32117 static constexpr char const * const typestr{"unsigned long long int"};
32118 static constexpr bool traverse{false};
32119 static constexpr auto mbr_ptr{&SgUnsignedLongLongIntVal::p_value};
32120 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32121 using bind = Desc<SgUnsignedLongLongIntVal, unsigned long long int SgUnsignedLongLongIntVal::*, &SgUnsignedLongLongIntVal::p_value>;
32122};
32123template <> struct describe_field_t<SgUnsignedLongLongIntVal,std::string,&SgUnsignedLongLongIntVal::p_valueString> {
32125 using field_type = std::string;
32126 static constexpr size_t position{1};
32127 static constexpr char const * const name{"valueString"};
32128 static constexpr char const * const typestr{"std::string"};
32129 static constexpr bool traverse{false};
32130 static constexpr auto mbr_ptr{&SgUnsignedLongLongIntVal::p_valueString};
32131 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32132 using bind = Desc<SgUnsignedLongLongIntVal, std::string SgUnsignedLongLongIntVal::*, &SgUnsignedLongLongIntVal::p_valueString>;
32133};
32136 using base = SgValueExp;
32137 static constexpr char const * const name{"UnsignedLongLongIntVal"};
32138 static constexpr unsigned long variant{814};
32139 static constexpr bool concrete{true};
32140 using subclasses_t = mp::List<>;
32142};
32143template <> struct node_from_variant_t<814> { using type = SgUnsignedLongLongIntVal; };
32144
32145// Class: UnsignedLongVal
32146template <> struct describe_field_t<SgUnsignedLongVal,unsigned long,&SgUnsignedLongVal::p_value> {
32147 using parent = SgUnsignedLongVal;
32148 using field_type = unsigned long;
32149 static constexpr size_t position{0};
32150 static constexpr char const * const name{"value"};
32151 static constexpr char const * const typestr{"unsigned long"};
32152 static constexpr bool traverse{false};
32153 static constexpr auto mbr_ptr{&SgUnsignedLongVal::p_value};
32154 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32155 using bind = Desc<SgUnsignedLongVal, unsigned long SgUnsignedLongVal::*, &SgUnsignedLongVal::p_value>;
32156};
32157template <> struct describe_field_t<SgUnsignedLongVal,std::string,&SgUnsignedLongVal::p_valueString> {
32158 using parent = SgUnsignedLongVal;
32159 using field_type = std::string;
32160 static constexpr size_t position{1};
32161 static constexpr char const * const name{"valueString"};
32162 static constexpr char const * const typestr{"std::string"};
32163 static constexpr bool traverse{false};
32164 static constexpr auto mbr_ptr{&SgUnsignedLongVal::p_valueString};
32165 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32166 using bind = Desc<SgUnsignedLongVal, std::string SgUnsignedLongVal::*, &SgUnsignedLongVal::p_valueString>;
32167};
32169 using node = SgUnsignedLongVal;
32170 using base = SgValueExp;
32171 static constexpr char const * const name{"UnsignedLongVal"};
32172 static constexpr unsigned long variant{815};
32173 static constexpr bool concrete{true};
32174 using subclasses_t = mp::List<>;
32176};
32177template <> struct node_from_variant_t<815> { using type = SgUnsignedLongVal; };
32178
32179// Class: UnsignedShortVal
32180template <> struct describe_field_t<SgUnsignedShortVal,unsigned short,&SgUnsignedShortVal::p_value> {
32181 using parent = SgUnsignedShortVal;
32182 using field_type = unsigned short;
32183 static constexpr size_t position{0};
32184 static constexpr char const * const name{"value"};
32185 static constexpr char const * const typestr{"unsigned short"};
32186 static constexpr bool traverse{false};
32187 static constexpr auto mbr_ptr{&SgUnsignedShortVal::p_value};
32188 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32189 using bind = Desc<SgUnsignedShortVal, unsigned short SgUnsignedShortVal::*, &SgUnsignedShortVal::p_value>;
32190};
32191template <> struct describe_field_t<SgUnsignedShortVal,std::string,&SgUnsignedShortVal::p_valueString> {
32192 using parent = SgUnsignedShortVal;
32193 using field_type = std::string;
32194 static constexpr size_t position{1};
32195 static constexpr char const * const name{"valueString"};
32196 static constexpr char const * const typestr{"std::string"};
32197 static constexpr bool traverse{false};
32198 static constexpr auto mbr_ptr{&SgUnsignedShortVal::p_valueString};
32199 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32200 using bind = Desc<SgUnsignedShortVal, std::string SgUnsignedShortVal::*, &SgUnsignedShortVal::p_valueString>;
32201};
32203 using node = SgUnsignedShortVal;
32204 using base = SgValueExp;
32205 static constexpr char const * const name{"UnsignedShortVal"};
32206 static constexpr unsigned long variant{816};
32207 static constexpr bool concrete{true};
32208 using subclasses_t = mp::List<>;
32210};
32211template <> struct node_from_variant_t<816> { using type = SgUnsignedShortVal; };
32212
32213// Class: UpcBarrierStatement
32214template <> struct describe_field_t<SgUpcBarrierStatement,SgExpression*,&SgUpcBarrierStatement::p_barrier_expression> {
32216 using field_type = SgExpression*;
32217 static constexpr size_t position{0};
32218 static constexpr char const * const name{"barrier_expression"};
32219 static constexpr char const * const typestr{"SgExpression*"};
32220 static constexpr bool traverse{true};
32221 static constexpr auto mbr_ptr{&SgUpcBarrierStatement::p_barrier_expression};
32222 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32223 using bind = Desc<SgUpcBarrierStatement, SgExpression* SgUpcBarrierStatement::*, &SgUpcBarrierStatement::p_barrier_expression>;
32224};
32227 using base = SgStatement;
32228 static constexpr char const * const name{"UpcBarrierStatement"};
32229 static constexpr unsigned long variant{817};
32230 static constexpr bool concrete{true};
32231 using subclasses_t = mp::List<>;
32233};
32234template <> struct node_from_variant_t<817> { using type = SgUpcBarrierStatement; };
32235
32236// Class: UpcBlocksizeofExpression
32237template <> struct describe_field_t<SgUpcBlocksizeofExpression,SgExpression*,&SgUpcBlocksizeofExpression::p_expression> {
32239 using field_type = SgExpression*;
32240 static constexpr size_t position{0};
32241 static constexpr char const * const name{"expression"};
32242 static constexpr char const * const typestr{"SgExpression*"};
32243 static constexpr bool traverse{true};
32244 static constexpr auto mbr_ptr{&SgUpcBlocksizeofExpression::p_expression};
32245 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32246 using bind = Desc<SgUpcBlocksizeofExpression, SgExpression* SgUpcBlocksizeofExpression::*, &SgUpcBlocksizeofExpression::p_expression>;
32247};
32248template <> struct describe_field_t<SgUpcBlocksizeofExpression,SgType*,&SgUpcBlocksizeofExpression::p_operand_type> {
32250 using field_type = SgType*;
32251 static constexpr size_t position{1};
32252 static constexpr char const * const name{"operand_type"};
32253 static constexpr char const * const typestr{"SgType*"};
32254 static constexpr bool traverse{false};
32255 static constexpr auto mbr_ptr{&SgUpcBlocksizeofExpression::p_operand_type};
32256 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32257 using bind = Desc<SgUpcBlocksizeofExpression, SgType* SgUpcBlocksizeofExpression::*, &SgUpcBlocksizeofExpression::p_operand_type>;
32258};
32259template <> struct describe_field_t<SgUpcBlocksizeofExpression,SgType*,&SgUpcBlocksizeofExpression::p_expression_type> {
32261 using field_type = SgType*;
32262 static constexpr size_t position{2};
32263 static constexpr char const * const name{"expression_type"};
32264 static constexpr char const * const typestr{"SgType*"};
32265 static constexpr bool traverse{false};
32266 static constexpr auto mbr_ptr{&SgUpcBlocksizeofExpression::p_expression_type};
32267 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32268 using bind = Desc<SgUpcBlocksizeofExpression, SgType* SgUpcBlocksizeofExpression::*, &SgUpcBlocksizeofExpression::p_expression_type>;
32269};
32279template <> struct node_from_variant_t<818> { using type = SgUpcBlocksizeofExpression; };
32280
32281// Class: UpcElemsizeofExpression
32282template <> struct describe_field_t<SgUpcElemsizeofExpression,SgExpression*,&SgUpcElemsizeofExpression::p_expression> {
32284 using field_type = SgExpression*;
32285 static constexpr size_t position{0};
32286 static constexpr char const * const name{"expression"};
32287 static constexpr char const * const typestr{"SgExpression*"};
32288 static constexpr bool traverse{true};
32289 static constexpr auto mbr_ptr{&SgUpcElemsizeofExpression::p_expression};
32290 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32291 using bind = Desc<SgUpcElemsizeofExpression, SgExpression* SgUpcElemsizeofExpression::*, &SgUpcElemsizeofExpression::p_expression>;
32292};
32293template <> struct describe_field_t<SgUpcElemsizeofExpression,SgType*,&SgUpcElemsizeofExpression::p_operand_type> {
32295 using field_type = SgType*;
32296 static constexpr size_t position{1};
32297 static constexpr char const * const name{"operand_type"};
32298 static constexpr char const * const typestr{"SgType*"};
32299 static constexpr bool traverse{false};
32300 static constexpr auto mbr_ptr{&SgUpcElemsizeofExpression::p_operand_type};
32301 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32302 using bind = Desc<SgUpcElemsizeofExpression, SgType* SgUpcElemsizeofExpression::*, &SgUpcElemsizeofExpression::p_operand_type>;
32303};
32304template <> struct describe_field_t<SgUpcElemsizeofExpression,SgType*,&SgUpcElemsizeofExpression::p_expression_type> {
32306 using field_type = SgType*;
32307 static constexpr size_t position{2};
32308 static constexpr char const * const name{"expression_type"};
32309 static constexpr char const * const typestr{"SgType*"};
32310 static constexpr bool traverse{false};
32311 static constexpr auto mbr_ptr{&SgUpcElemsizeofExpression::p_expression_type};
32312 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32313 using bind = Desc<SgUpcElemsizeofExpression, SgType* SgUpcElemsizeofExpression::*, &SgUpcElemsizeofExpression::p_expression_type>;
32314};
32324template <> struct node_from_variant_t<819> { using type = SgUpcElemsizeofExpression; };
32325
32326// Class: UpcFenceStatement
32328 using node = SgUpcFenceStatement;
32329 using base = SgStatement;
32330 static constexpr char const * const name{"UpcFenceStatement"};
32331 static constexpr unsigned long variant{820};
32332 static constexpr bool concrete{true};
32333 using subclasses_t = mp::List<>;
32334 using fields_t = mp::List<>;
32335};
32336template <> struct node_from_variant_t<820> { using type = SgUpcFenceStatement; };
32337
32338// Class: UpcForAllStatement
32339template <> struct describe_field_t<SgUpcForAllStatement,SgForInitStatement*,&SgUpcForAllStatement::p_for_init_stmt> {
32342 static constexpr size_t position{0};
32343 static constexpr char const * const name{"for_init_stmt"};
32344 static constexpr char const * const typestr{"SgForInitStatement*"};
32345 static constexpr bool traverse{true};
32346 static constexpr auto mbr_ptr{&SgUpcForAllStatement::p_for_init_stmt};
32347 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32348 using bind = Desc<SgUpcForAllStatement, SgForInitStatement* SgUpcForAllStatement::*, &SgUpcForAllStatement::p_for_init_stmt>;
32349};
32350template <> struct describe_field_t<SgUpcForAllStatement,SgStatement*,&SgUpcForAllStatement::p_test> {
32352 using field_type = SgStatement*;
32353 static constexpr size_t position{1};
32354 static constexpr char const * const name{"test"};
32355 static constexpr char const * const typestr{"SgStatement*"};
32356 static constexpr bool traverse{true};
32357 static constexpr auto mbr_ptr{&SgUpcForAllStatement::p_test};
32358 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32359 using bind = Desc<SgUpcForAllStatement, SgStatement* SgUpcForAllStatement::*, &SgUpcForAllStatement::p_test>;
32360};
32361template <> struct describe_field_t<SgUpcForAllStatement,SgExpression*,&SgUpcForAllStatement::p_increment> {
32363 using field_type = SgExpression*;
32364 static constexpr size_t position{2};
32365 static constexpr char const * const name{"increment"};
32366 static constexpr char const * const typestr{"SgExpression*"};
32367 static constexpr bool traverse{true};
32368 static constexpr auto mbr_ptr{&SgUpcForAllStatement::p_increment};
32369 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32370 using bind = Desc<SgUpcForAllStatement, SgExpression* SgUpcForAllStatement::*, &SgUpcForAllStatement::p_increment>;
32371};
32372template <> struct describe_field_t<SgUpcForAllStatement,SgExpression*,&SgUpcForAllStatement::p_affinity> {
32374 using field_type = SgExpression*;
32375 static constexpr size_t position{3};
32376 static constexpr char const * const name{"affinity"};
32377 static constexpr char const * const typestr{"SgExpression*"};
32378 static constexpr bool traverse{true};
32379 static constexpr auto mbr_ptr{&SgUpcForAllStatement::p_affinity};
32380 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32381 using bind = Desc<SgUpcForAllStatement, SgExpression* SgUpcForAllStatement::*, &SgUpcForAllStatement::p_affinity>;
32382};
32383template <> struct describe_field_t<SgUpcForAllStatement,SgStatement*,&SgUpcForAllStatement::p_loop_body> {
32385 using field_type = SgStatement*;
32386 static constexpr size_t position{4};
32387 static constexpr char const * const name{"loop_body"};
32388 static constexpr char const * const typestr{"SgStatement*"};
32389 static constexpr bool traverse{true};
32390 static constexpr auto mbr_ptr{&SgUpcForAllStatement::p_loop_body};
32391 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32392 using bind = Desc<SgUpcForAllStatement, SgStatement* SgUpcForAllStatement::*, &SgUpcForAllStatement::p_loop_body>;
32393};
32403template <> struct node_from_variant_t<821> { using type = SgUpcForAllStatement; };
32404
32405// Class: UpcLocalsizeofExpression
32406template <> struct describe_field_t<SgUpcLocalsizeofExpression,SgExpression*,&SgUpcLocalsizeofExpression::p_expression> {
32408 using field_type = SgExpression*;
32409 static constexpr size_t position{0};
32410 static constexpr char const * const name{"expression"};
32411 static constexpr char const * const typestr{"SgExpression*"};
32412 static constexpr bool traverse{true};
32413 static constexpr auto mbr_ptr{&SgUpcLocalsizeofExpression::p_expression};
32414 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32415 using bind = Desc<SgUpcLocalsizeofExpression, SgExpression* SgUpcLocalsizeofExpression::*, &SgUpcLocalsizeofExpression::p_expression>;
32416};
32417template <> struct describe_field_t<SgUpcLocalsizeofExpression,SgType*,&SgUpcLocalsizeofExpression::p_operand_type> {
32419 using field_type = SgType*;
32420 static constexpr size_t position{1};
32421 static constexpr char const * const name{"operand_type"};
32422 static constexpr char const * const typestr{"SgType*"};
32423 static constexpr bool traverse{false};
32424 static constexpr auto mbr_ptr{&SgUpcLocalsizeofExpression::p_operand_type};
32425 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32426 using bind = Desc<SgUpcLocalsizeofExpression, SgType* SgUpcLocalsizeofExpression::*, &SgUpcLocalsizeofExpression::p_operand_type>;
32427};
32428template <> struct describe_field_t<SgUpcLocalsizeofExpression,SgType*,&SgUpcLocalsizeofExpression::p_expression_type> {
32430 using field_type = SgType*;
32431 static constexpr size_t position{2};
32432 static constexpr char const * const name{"expression_type"};
32433 static constexpr char const * const typestr{"SgType*"};
32434 static constexpr bool traverse{false};
32435 static constexpr auto mbr_ptr{&SgUpcLocalsizeofExpression::p_expression_type};
32436 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32437 using bind = Desc<SgUpcLocalsizeofExpression, SgType* SgUpcLocalsizeofExpression::*, &SgUpcLocalsizeofExpression::p_expression_type>;
32438};
32448template <> struct node_from_variant_t<822> { using type = SgUpcLocalsizeofExpression; };
32449
32450// Class: UpcMythread
32451template <> struct describe_field_t<SgUpcMythread,int,&SgUpcMythread::p_value> {
32452 using parent = SgUpcMythread;
32453 using field_type = int;
32454 static constexpr size_t position{0};
32455 static constexpr char const * const name{"value"};
32456 static constexpr char const * const typestr{"int"};
32457 static constexpr bool traverse{false};
32458 static constexpr auto mbr_ptr{&SgUpcMythread::p_value};
32459 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32460 using bind = Desc<SgUpcMythread, int SgUpcMythread::*, &SgUpcMythread::p_value>;
32461};
32462template <> struct describe_field_t<SgUpcMythread,std::string,&SgUpcMythread::p_valueString> {
32463 using parent = SgUpcMythread;
32464 using field_type = std::string;
32465 static constexpr size_t position{1};
32466 static constexpr char const * const name{"valueString"};
32467 static constexpr char const * const typestr{"std::string"};
32468 static constexpr bool traverse{false};
32469 static constexpr auto mbr_ptr{&SgUpcMythread::p_valueString};
32470 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32471 using bind = Desc<SgUpcMythread, std::string SgUpcMythread::*, &SgUpcMythread::p_valueString>;
32472};
32473template <> struct describe_node_t<SgUpcMythread> {
32474 using node = SgUpcMythread;
32475 using base = SgValueExp;
32476 static constexpr char const * const name{"UpcMythread"};
32477 static constexpr unsigned long variant{823};
32478 static constexpr bool concrete{true};
32479 using subclasses_t = mp::List<>;
32481};
32482template <> struct node_from_variant_t<823> { using type = SgUpcMythread; };
32483
32484// Class: UpcNotifyStatement
32485template <> struct describe_field_t<SgUpcNotifyStatement,SgExpression*,&SgUpcNotifyStatement::p_notify_expression> {
32487 using field_type = SgExpression*;
32488 static constexpr size_t position{0};
32489 static constexpr char const * const name{"notify_expression"};
32490 static constexpr char const * const typestr{"SgExpression*"};
32491 static constexpr bool traverse{true};
32492 static constexpr auto mbr_ptr{&SgUpcNotifyStatement::p_notify_expression};
32493 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32494 using bind = Desc<SgUpcNotifyStatement, SgExpression* SgUpcNotifyStatement::*, &SgUpcNotifyStatement::p_notify_expression>;
32495};
32497 using node = SgUpcNotifyStatement;
32498 using base = SgStatement;
32499 static constexpr char const * const name{"UpcNotifyStatement"};
32500 static constexpr unsigned long variant{824};
32501 static constexpr bool concrete{true};
32502 using subclasses_t = mp::List<>;
32504};
32505template <> struct node_from_variant_t<824> { using type = SgUpcNotifyStatement; };
32506
32507// Class: UpcThreads
32508template <> struct describe_field_t<SgUpcThreads,int,&SgUpcThreads::p_value> {
32509 using parent = SgUpcThreads;
32510 using field_type = int;
32511 static constexpr size_t position{0};
32512 static constexpr char const * const name{"value"};
32513 static constexpr char const * const typestr{"int"};
32514 static constexpr bool traverse{false};
32515 static constexpr auto mbr_ptr{&SgUpcThreads::p_value};
32516 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32517 using bind = Desc<SgUpcThreads, int SgUpcThreads::*, &SgUpcThreads::p_value>;
32518};
32519template <> struct describe_field_t<SgUpcThreads,std::string,&SgUpcThreads::p_valueString> {
32520 using parent = SgUpcThreads;
32521 using field_type = std::string;
32522 static constexpr size_t position{1};
32523 static constexpr char const * const name{"valueString"};
32524 static constexpr char const * const typestr{"std::string"};
32525 static constexpr bool traverse{false};
32526 static constexpr auto mbr_ptr{&SgUpcThreads::p_valueString};
32527 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32528 using bind = Desc<SgUpcThreads, std::string SgUpcThreads::*, &SgUpcThreads::p_valueString>;
32529};
32530template <> struct describe_node_t<SgUpcThreads> {
32531 using node = SgUpcThreads;
32532 using base = SgValueExp;
32533 static constexpr char const * const name{"UpcThreads"};
32534 static constexpr unsigned long variant{825};
32535 static constexpr bool concrete{true};
32536 using subclasses_t = mp::List<>;
32538};
32539template <> struct node_from_variant_t<825> { using type = SgUpcThreads; };
32540
32541// Class: UpcWaitStatement
32542template <> struct describe_field_t<SgUpcWaitStatement,SgExpression*,&SgUpcWaitStatement::p_wait_expression> {
32543 using parent = SgUpcWaitStatement;
32544 using field_type = SgExpression*;
32545 static constexpr size_t position{0};
32546 static constexpr char const * const name{"wait_expression"};
32547 static constexpr char const * const typestr{"SgExpression*"};
32548 static constexpr bool traverse{true};
32549 static constexpr auto mbr_ptr{&SgUpcWaitStatement::p_wait_expression};
32550 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32551 using bind = Desc<SgUpcWaitStatement, SgExpression* SgUpcWaitStatement::*, &SgUpcWaitStatement::p_wait_expression>;
32552};
32554 using node = SgUpcWaitStatement;
32555 using base = SgStatement;
32556 static constexpr char const * const name{"UpcWaitStatement"};
32557 static constexpr unsigned long variant{826};
32558 static constexpr bool concrete{true};
32559 using subclasses_t = mp::List<>;
32561};
32562template <> struct node_from_variant_t<826> { using type = SgUpcWaitStatement; };
32563
32564// Class: UseStatement
32565template <> struct describe_field_t<SgUseStatement,SgName,&SgUseStatement::p_name> {
32566 using parent = SgUseStatement;
32567 using field_type = SgName;
32568 static constexpr size_t position{0};
32569 static constexpr char const * const name{"name"};
32570 static constexpr char const * const typestr{"SgName"};
32571 static constexpr bool traverse{false};
32572 static constexpr auto mbr_ptr{&SgUseStatement::p_name};
32573 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32574 using bind = Desc<SgUseStatement, SgName SgUseStatement::*, &SgUseStatement::p_name>;
32575};
32576template <> struct describe_field_t<SgUseStatement,bool,&SgUseStatement::p_only_option> {
32577 using parent = SgUseStatement;
32578 using field_type = bool;
32579 static constexpr size_t position{1};
32580 static constexpr char const * const name{"only_option"};
32581 static constexpr char const * const typestr{"bool"};
32582 static constexpr bool traverse{false};
32583 static constexpr auto mbr_ptr{&SgUseStatement::p_only_option};
32584 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32585 using bind = Desc<SgUseStatement, bool SgUseStatement::*, &SgUseStatement::p_only_option>;
32586};
32587template <> struct describe_field_t<SgUseStatement,std::string,&SgUseStatement::p_module_nature> {
32588 using parent = SgUseStatement;
32589 using field_type = std::string;
32590 static constexpr size_t position{2};
32591 static constexpr char const * const name{"module_nature"};
32592 static constexpr char const * const typestr{"std::string"};
32593 static constexpr bool traverse{false};
32594 static constexpr auto mbr_ptr{&SgUseStatement::p_module_nature};
32595 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32596 using bind = Desc<SgUseStatement, std::string SgUseStatement::*, &SgUseStatement::p_module_nature>;
32597};
32598template <> struct describe_field_t<SgUseStatement,SgRenamePairPtrList,&SgUseStatement::p_rename_list> {
32599 using parent = SgUseStatement;
32600 using field_type = SgRenamePairPtrList;
32601 static constexpr size_t position{3};
32602 static constexpr char const * const name{"rename_list"};
32603 static constexpr char const * const typestr{"SgRenamePairPtrList"};
32604 static constexpr bool traverse{true};
32605 static constexpr auto mbr_ptr{&SgUseStatement::p_rename_list};
32606 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32607 using bind = Desc<SgUseStatement, SgRenamePairPtrList SgUseStatement::*, &SgUseStatement::p_rename_list>;
32608};
32609template <> struct describe_field_t<SgUseStatement,SgModuleStatement*,&SgUseStatement::p_module> {
32610 using parent = SgUseStatement;
32612 static constexpr size_t position{4};
32613 static constexpr char const * const name{"module"};
32614 static constexpr char const * const typestr{"SgModuleStatement*"};
32615 static constexpr bool traverse{false};
32616 static constexpr auto mbr_ptr{&SgUseStatement::p_module};
32617 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32618 using bind = Desc<SgUseStatement, SgModuleStatement* SgUseStatement::*, &SgUseStatement::p_module>;
32619};
32629template <> struct node_from_variant_t<827> { using type = SgUseStatement; };
32630
32631// Class: UserDefinedBinaryOp
32632template <> struct describe_field_t<SgUserDefinedBinaryOp,SgName,&SgUserDefinedBinaryOp::p_operator_name> {
32634 using field_type = SgName;
32635 static constexpr size_t position{0};
32636 static constexpr char const * const name{"operator_name"};
32637 static constexpr char const * const typestr{"SgName"};
32638 static constexpr bool traverse{false};
32639 static constexpr auto mbr_ptr{&SgUserDefinedBinaryOp::p_operator_name};
32640 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32641 using bind = Desc<SgUserDefinedBinaryOp, SgName SgUserDefinedBinaryOp::*, &SgUserDefinedBinaryOp::p_operator_name>;
32642};
32643template <> struct describe_field_t<SgUserDefinedBinaryOp,SgFunctionSymbol*,&SgUserDefinedBinaryOp::p_symbol> {
32646 static constexpr size_t position{1};
32647 static constexpr char const * const name{"symbol"};
32648 static constexpr char const * const typestr{"SgFunctionSymbol*"};
32649 static constexpr bool traverse{false};
32650 static constexpr auto mbr_ptr{&SgUserDefinedBinaryOp::p_symbol};
32651 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32652 using bind = Desc<SgUserDefinedBinaryOp, SgFunctionSymbol* SgUserDefinedBinaryOp::*, &SgUserDefinedBinaryOp::p_symbol>;
32653};
32656 using base = SgBinaryOp;
32657 static constexpr char const * const name{"UserDefinedBinaryOp"};
32658 static constexpr unsigned long variant{828};
32659 static constexpr bool concrete{true};
32660 using subclasses_t = mp::List<>;
32662};
32663template <> struct node_from_variant_t<828> { using type = SgUserDefinedBinaryOp; };
32664
32665// Class: UserDefinedUnaryOp
32666template <> struct describe_field_t<SgUserDefinedUnaryOp,SgName,&SgUserDefinedUnaryOp::p_operator_name> {
32668 using field_type = SgName;
32669 static constexpr size_t position{0};
32670 static constexpr char const * const name{"operator_name"};
32671 static constexpr char const * const typestr{"SgName"};
32672 static constexpr bool traverse{false};
32673 static constexpr auto mbr_ptr{&SgUserDefinedUnaryOp::p_operator_name};
32674 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32675 using bind = Desc<SgUserDefinedUnaryOp, SgName SgUserDefinedUnaryOp::*, &SgUserDefinedUnaryOp::p_operator_name>;
32676};
32677template <> struct describe_field_t<SgUserDefinedUnaryOp,SgFunctionSymbol*,&SgUserDefinedUnaryOp::p_symbol> {
32680 static constexpr size_t position{1};
32681 static constexpr char const * const name{"symbol"};
32682 static constexpr char const * const typestr{"SgFunctionSymbol*"};
32683 static constexpr bool traverse{false};
32684 static constexpr auto mbr_ptr{&SgUserDefinedUnaryOp::p_symbol};
32685 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32686 using bind = Desc<SgUserDefinedUnaryOp, SgFunctionSymbol* SgUserDefinedUnaryOp::*, &SgUserDefinedUnaryOp::p_symbol>;
32687};
32689 using node = SgUserDefinedUnaryOp;
32690 using base = SgUnaryOp;
32691 static constexpr char const * const name{"UserDefinedUnaryOp"};
32692 static constexpr unsigned long variant{829};
32693 static constexpr bool concrete{true};
32694 using subclasses_t = mp::List<>;
32696};
32697template <> struct node_from_variant_t<829> { using type = SgUserDefinedUnaryOp; };
32698
32699// Class: UsingDeclarationStatement
32703 static constexpr size_t position{0};
32704 static constexpr char const * const name{"declaration"};
32705 static constexpr char const * const typestr{"SgDeclarationStatement*"};
32706 static constexpr bool traverse{false};
32707 static constexpr auto mbr_ptr{&SgUsingDeclarationStatement::p_declaration};
32708 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32709 using bind = Desc<SgUsingDeclarationStatement, SgDeclarationStatement* SgUsingDeclarationStatement::*, &SgUsingDeclarationStatement::p_declaration>;
32710};
32714 static constexpr size_t position{1};
32715 static constexpr char const * const name{"initializedName"};
32716 static constexpr char const * const typestr{"SgInitializedName*"};
32717 static constexpr bool traverse{false};
32718 static constexpr auto mbr_ptr{&SgUsingDeclarationStatement::p_initializedName};
32719 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32720 using bind = Desc<SgUsingDeclarationStatement, SgInitializedName* SgUsingDeclarationStatement::*, &SgUsingDeclarationStatement::p_initializedName>;
32721};
32722template <> struct describe_field_t<SgUsingDeclarationStatement,int,&SgUsingDeclarationStatement::p_name_qualification_length> {
32724 using field_type = int;
32725 static constexpr size_t position{2};
32726 static constexpr char const * const name{"name_qualification_length"};
32727 static constexpr char const * const typestr{"int"};
32728 static constexpr bool traverse{false};
32729 static constexpr auto mbr_ptr{&SgUsingDeclarationStatement::p_name_qualification_length};
32730 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32731 using bind = Desc<SgUsingDeclarationStatement, int SgUsingDeclarationStatement::*, &SgUsingDeclarationStatement::p_name_qualification_length>;
32732};
32733template <> struct describe_field_t<SgUsingDeclarationStatement,bool,&SgUsingDeclarationStatement::p_type_elaboration_required> {
32735 using field_type = bool;
32736 static constexpr size_t position{3};
32737 static constexpr char const * const name{"type_elaboration_required"};
32738 static constexpr char const * const typestr{"bool"};
32739 static constexpr bool traverse{false};
32740 static constexpr auto mbr_ptr{&SgUsingDeclarationStatement::p_type_elaboration_required};
32741 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32742 using bind = Desc<SgUsingDeclarationStatement, bool SgUsingDeclarationStatement::*, &SgUsingDeclarationStatement::p_type_elaboration_required>;
32743};
32744template <> struct describe_field_t<SgUsingDeclarationStatement,bool,&SgUsingDeclarationStatement::p_global_qualification_required> {
32746 using field_type = bool;
32747 static constexpr size_t position{4};
32748 static constexpr char const * const name{"global_qualification_required"};
32749 static constexpr char const * const typestr{"bool"};
32750 static constexpr bool traverse{false};
32751 static constexpr auto mbr_ptr{&SgUsingDeclarationStatement::p_global_qualification_required};
32752 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32753 using bind = Desc<SgUsingDeclarationStatement, bool SgUsingDeclarationStatement::*, &SgUsingDeclarationStatement::p_global_qualification_required>;
32754};
32755template <> struct describe_field_t<SgUsingDeclarationStatement,bool,&SgUsingDeclarationStatement::p_is_inheriting_constructor> {
32757 using field_type = bool;
32758 static constexpr size_t position{5};
32759 static constexpr char const * const name{"is_inheriting_constructor"};
32760 static constexpr char const * const typestr{"bool"};
32761 static constexpr bool traverse{false};
32762 static constexpr auto mbr_ptr{&SgUsingDeclarationStatement::p_is_inheriting_constructor};
32763 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32764 using bind = Desc<SgUsingDeclarationStatement, bool SgUsingDeclarationStatement::*, &SgUsingDeclarationStatement::p_is_inheriting_constructor>;
32765};
32766template <> struct describe_field_t<SgUsingDeclarationStatement,SgName,&SgUsingDeclarationStatement::p_adaTypeAttribute> {
32768 using field_type = SgName;
32769 static constexpr size_t position{6};
32770 static constexpr char const * const name{"adaTypeAttribute"};
32771 static constexpr char const * const typestr{"SgName"};
32772 static constexpr bool traverse{false};
32773 static constexpr auto mbr_ptr{&SgUsingDeclarationStatement::p_adaTypeAttribute};
32774 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32775 using bind = Desc<SgUsingDeclarationStatement, SgName SgUsingDeclarationStatement::*, &SgUsingDeclarationStatement::p_adaTypeAttribute>;
32776};
32786template <> struct node_from_variant_t<830> { using type = SgUsingDeclarationStatement; };
32787
32788// Class: UsingDirectiveStatement
32792 static constexpr size_t position{0};
32793 static constexpr char const * const name{"namespaceDeclaration"};
32794 static constexpr char const * const typestr{"SgNamespaceDeclarationStatement*"};
32795 static constexpr bool traverse{false};
32796 static constexpr auto mbr_ptr{&SgUsingDirectiveStatement::p_namespaceDeclaration};
32797 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32798 using bind = Desc<SgUsingDirectiveStatement, SgNamespaceDeclarationStatement* SgUsingDirectiveStatement::*, &SgUsingDirectiveStatement::p_namespaceDeclaration>;
32799};
32800template <> struct describe_field_t<SgUsingDirectiveStatement,int,&SgUsingDirectiveStatement::p_name_qualification_length> {
32802 using field_type = int;
32803 static constexpr size_t position{1};
32804 static constexpr char const * const name{"name_qualification_length"};
32805 static constexpr char const * const typestr{"int"};
32806 static constexpr bool traverse{false};
32807 static constexpr auto mbr_ptr{&SgUsingDirectiveStatement::p_name_qualification_length};
32808 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32809 using bind = Desc<SgUsingDirectiveStatement, int SgUsingDirectiveStatement::*, &SgUsingDirectiveStatement::p_name_qualification_length>;
32810};
32811template <> struct describe_field_t<SgUsingDirectiveStatement,bool,&SgUsingDirectiveStatement::p_type_elaboration_required> {
32813 using field_type = bool;
32814 static constexpr size_t position{2};
32815 static constexpr char const * const name{"type_elaboration_required"};
32816 static constexpr char const * const typestr{"bool"};
32817 static constexpr bool traverse{false};
32818 static constexpr auto mbr_ptr{&SgUsingDirectiveStatement::p_type_elaboration_required};
32819 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32820 using bind = Desc<SgUsingDirectiveStatement, bool SgUsingDirectiveStatement::*, &SgUsingDirectiveStatement::p_type_elaboration_required>;
32821};
32822template <> struct describe_field_t<SgUsingDirectiveStatement,bool,&SgUsingDirectiveStatement::p_global_qualification_required> {
32824 using field_type = bool;
32825 static constexpr size_t position{3};
32826 static constexpr char const * const name{"global_qualification_required"};
32827 static constexpr char const * const typestr{"bool"};
32828 static constexpr bool traverse{false};
32829 static constexpr auto mbr_ptr{&SgUsingDirectiveStatement::p_global_qualification_required};
32830 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32831 using bind = Desc<SgUsingDirectiveStatement, bool SgUsingDirectiveStatement::*, &SgUsingDirectiveStatement::p_global_qualification_required>;
32832};
32842template <> struct node_from_variant_t<831> { using type = SgUsingDirectiveStatement; };
32843
32844// Class: ValueExp
32845template <> struct describe_field_t<SgValueExp,SgExpression*,&SgValueExp::p_originalExpressionTree> {
32846 using parent = SgValueExp;
32847 using field_type = SgExpression*;
32848 static constexpr size_t position{0};
32849 static constexpr char const * const name{"originalExpressionTree"};
32850 static constexpr char const * const typestr{"SgExpression*"};
32851 static constexpr bool traverse{false};
32852 static constexpr auto mbr_ptr{&SgValueExp::p_originalExpressionTree};
32853 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32854 using bind = Desc<SgValueExp, SgExpression* SgValueExp::*, &SgValueExp::p_originalExpressionTree>;
32855};
32865template <> struct node_from_variant_t<832> { using type = SgValueExp; };
32866
32867// Class: VarArgCopyOp
32868template <> struct describe_field_t<SgVarArgCopyOp,SgExpression*,&SgVarArgCopyOp::p_lhs_operand> {
32869 using parent = SgVarArgCopyOp;
32870 using field_type = SgExpression*;
32871 static constexpr size_t position{0};
32872 static constexpr char const * const name{"lhs_operand"};
32873 static constexpr char const * const typestr{"SgExpression*"};
32874 static constexpr bool traverse{true};
32875 static constexpr auto mbr_ptr{&SgVarArgCopyOp::p_lhs_operand};
32876 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32877 using bind = Desc<SgVarArgCopyOp, SgExpression* SgVarArgCopyOp::*, &SgVarArgCopyOp::p_lhs_operand>;
32878};
32879template <> struct describe_field_t<SgVarArgCopyOp,SgExpression*,&SgVarArgCopyOp::p_rhs_operand> {
32880 using parent = SgVarArgCopyOp;
32881 using field_type = SgExpression*;
32882 static constexpr size_t position{1};
32883 static constexpr char const * const name{"rhs_operand"};
32884 static constexpr char const * const typestr{"SgExpression*"};
32885 static constexpr bool traverse{true};
32886 static constexpr auto mbr_ptr{&SgVarArgCopyOp::p_rhs_operand};
32887 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32888 using bind = Desc<SgVarArgCopyOp, SgExpression* SgVarArgCopyOp::*, &SgVarArgCopyOp::p_rhs_operand>;
32889};
32890template <> struct describe_field_t<SgVarArgCopyOp,SgType*,&SgVarArgCopyOp::p_expression_type> {
32891 using parent = SgVarArgCopyOp;
32892 using field_type = SgType*;
32893 static constexpr size_t position{2};
32894 static constexpr char const * const name{"expression_type"};
32895 static constexpr char const * const typestr{"SgType*"};
32896 static constexpr bool traverse{false};
32897 static constexpr auto mbr_ptr{&SgVarArgCopyOp::p_expression_type};
32898 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32899 using bind = Desc<SgVarArgCopyOp, SgType* SgVarArgCopyOp::*, &SgVarArgCopyOp::p_expression_type>;
32900};
32901template <> struct describe_node_t<SgVarArgCopyOp> {
32902 using node = SgVarArgCopyOp;
32903 using base = SgExpression;
32904 static constexpr char const * const name{"VarArgCopyOp"};
32905 static constexpr unsigned long variant{833};
32906 static constexpr bool concrete{true};
32907 using subclasses_t = mp::List<>;
32909};
32910template <> struct node_from_variant_t<833> { using type = SgVarArgCopyOp; };
32911
32912// Class: VarArgEndOp
32913template <> struct describe_field_t<SgVarArgEndOp,SgExpression*,&SgVarArgEndOp::p_operand_expr> {
32914 using parent = SgVarArgEndOp;
32915 using field_type = SgExpression*;
32916 static constexpr size_t position{0};
32917 static constexpr char const * const name{"operand_expr"};
32918 static constexpr char const * const typestr{"SgExpression*"};
32919 static constexpr bool traverse{true};
32920 static constexpr auto mbr_ptr{&SgVarArgEndOp::p_operand_expr};
32921 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32922 using bind = Desc<SgVarArgEndOp, SgExpression* SgVarArgEndOp::*, &SgVarArgEndOp::p_operand_expr>;
32923};
32924template <> struct describe_field_t<SgVarArgEndOp,SgType*,&SgVarArgEndOp::p_expression_type> {
32925 using parent = SgVarArgEndOp;
32926 using field_type = SgType*;
32927 static constexpr size_t position{1};
32928 static constexpr char const * const name{"expression_type"};
32929 static constexpr char const * const typestr{"SgType*"};
32930 static constexpr bool traverse{false};
32931 static constexpr auto mbr_ptr{&SgVarArgEndOp::p_expression_type};
32932 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32933 using bind = Desc<SgVarArgEndOp, SgType* SgVarArgEndOp::*, &SgVarArgEndOp::p_expression_type>;
32934};
32935template <> struct describe_node_t<SgVarArgEndOp> {
32936 using node = SgVarArgEndOp;
32937 using base = SgExpression;
32938 static constexpr char const * const name{"VarArgEndOp"};
32939 static constexpr unsigned long variant{834};
32940 static constexpr bool concrete{true};
32941 using subclasses_t = mp::List<>;
32943};
32944template <> struct node_from_variant_t<834> { using type = SgVarArgEndOp; };
32945
32946// Class: VarArgOp
32947template <> struct describe_field_t<SgVarArgOp,SgExpression*,&SgVarArgOp::p_operand_expr> {
32948 using parent = SgVarArgOp;
32949 using field_type = SgExpression*;
32950 static constexpr size_t position{0};
32951 static constexpr char const * const name{"operand_expr"};
32952 static constexpr char const * const typestr{"SgExpression*"};
32953 static constexpr bool traverse{true};
32954 static constexpr auto mbr_ptr{&SgVarArgOp::p_operand_expr};
32955 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32956 using bind = Desc<SgVarArgOp, SgExpression* SgVarArgOp::*, &SgVarArgOp::p_operand_expr>;
32957};
32958template <> struct describe_field_t<SgVarArgOp,SgType*,&SgVarArgOp::p_expression_type> {
32959 using parent = SgVarArgOp;
32960 using field_type = SgType*;
32961 static constexpr size_t position{1};
32962 static constexpr char const * const name{"expression_type"};
32963 static constexpr char const * const typestr{"SgType*"};
32964 static constexpr bool traverse{false};
32965 static constexpr auto mbr_ptr{&SgVarArgOp::p_expression_type};
32966 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32967 using bind = Desc<SgVarArgOp, SgType* SgVarArgOp::*, &SgVarArgOp::p_expression_type>;
32968};
32969template <> struct describe_node_t<SgVarArgOp> {
32970 using node = SgVarArgOp;
32971 using base = SgExpression;
32972 static constexpr char const * const name{"VarArgOp"};
32973 static constexpr unsigned long variant{835};
32974 static constexpr bool concrete{true};
32975 using subclasses_t = mp::List<>;
32977};
32978template <> struct node_from_variant_t<835> { using type = SgVarArgOp; };
32979
32980// Class: VarArgStartOneOperandOp
32981template <> struct describe_field_t<SgVarArgStartOneOperandOp,SgExpression*,&SgVarArgStartOneOperandOp::p_operand_expr> {
32983 using field_type = SgExpression*;
32984 static constexpr size_t position{0};
32985 static constexpr char const * const name{"operand_expr"};
32986 static constexpr char const * const typestr{"SgExpression*"};
32987 static constexpr bool traverse{true};
32988 static constexpr auto mbr_ptr{&SgVarArgStartOneOperandOp::p_operand_expr};
32989 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
32990 using bind = Desc<SgVarArgStartOneOperandOp, SgExpression* SgVarArgStartOneOperandOp::*, &SgVarArgStartOneOperandOp::p_operand_expr>;
32991};
32992template <> struct describe_field_t<SgVarArgStartOneOperandOp,SgType*,&SgVarArgStartOneOperandOp::p_expression_type> {
32994 using field_type = SgType*;
32995 static constexpr size_t position{1};
32996 static constexpr char const * const name{"expression_type"};
32997 static constexpr char const * const typestr{"SgType*"};
32998 static constexpr bool traverse{false};
32999 static constexpr auto mbr_ptr{&SgVarArgStartOneOperandOp::p_expression_type};
33000 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33001 using bind = Desc<SgVarArgStartOneOperandOp, SgType* SgVarArgStartOneOperandOp::*, &SgVarArgStartOneOperandOp::p_expression_type>;
33002};
33005 using base = SgExpression;
33006 static constexpr char const * const name{"VarArgStartOneOperandOp"};
33007 static constexpr unsigned long variant{836};
33008 static constexpr bool concrete{true};
33009 using subclasses_t = mp::List<>;
33011};
33012template <> struct node_from_variant_t<836> { using type = SgVarArgStartOneOperandOp; };
33013
33014// Class: VarArgStartOp
33015template <> struct describe_field_t<SgVarArgStartOp,SgExpression*,&SgVarArgStartOp::p_lhs_operand> {
33016 using parent = SgVarArgStartOp;
33017 using field_type = SgExpression*;
33018 static constexpr size_t position{0};
33019 static constexpr char const * const name{"lhs_operand"};
33020 static constexpr char const * const typestr{"SgExpression*"};
33021 static constexpr bool traverse{true};
33022 static constexpr auto mbr_ptr{&SgVarArgStartOp::p_lhs_operand};
33023 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33024 using bind = Desc<SgVarArgStartOp, SgExpression* SgVarArgStartOp::*, &SgVarArgStartOp::p_lhs_operand>;
33025};
33026template <> struct describe_field_t<SgVarArgStartOp,SgExpression*,&SgVarArgStartOp::p_rhs_operand> {
33027 using parent = SgVarArgStartOp;
33028 using field_type = SgExpression*;
33029 static constexpr size_t position{1};
33030 static constexpr char const * const name{"rhs_operand"};
33031 static constexpr char const * const typestr{"SgExpression*"};
33032 static constexpr bool traverse{true};
33033 static constexpr auto mbr_ptr{&SgVarArgStartOp::p_rhs_operand};
33034 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33035 using bind = Desc<SgVarArgStartOp, SgExpression* SgVarArgStartOp::*, &SgVarArgStartOp::p_rhs_operand>;
33036};
33037template <> struct describe_field_t<SgVarArgStartOp,SgType*,&SgVarArgStartOp::p_expression_type> {
33038 using parent = SgVarArgStartOp;
33039 using field_type = SgType*;
33040 static constexpr size_t position{2};
33041 static constexpr char const * const name{"expression_type"};
33042 static constexpr char const * const typestr{"SgType*"};
33043 static constexpr bool traverse{false};
33044 static constexpr auto mbr_ptr{&SgVarArgStartOp::p_expression_type};
33045 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33046 using bind = Desc<SgVarArgStartOp, SgType* SgVarArgStartOp::*, &SgVarArgStartOp::p_expression_type>;
33047};
33049 using node = SgVarArgStartOp;
33050 using base = SgExpression;
33051 static constexpr char const * const name{"VarArgStartOp"};
33052 static constexpr unsigned long variant{837};
33053 static constexpr bool concrete{true};
33054 using subclasses_t = mp::List<>;
33056};
33057template <> struct node_from_variant_t<837> { using type = SgVarArgStartOp; };
33058
33059// Class: VarRefExp
33060template <> struct describe_field_t<SgVarRefExp,SgVariableSymbol*,&SgVarRefExp::p_symbol> {
33061 using parent = SgVarRefExp;
33063 static constexpr size_t position{0};
33064 static constexpr char const * const name{"symbol"};
33065 static constexpr char const * const typestr{"SgVariableSymbol*"};
33066 static constexpr bool traverse{false};
33067 static constexpr auto mbr_ptr{&SgVarRefExp::p_symbol};
33068 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33069 using bind = Desc<SgVarRefExp, SgVariableSymbol* SgVarRefExp::*, &SgVarRefExp::p_symbol>;
33070};
33071template <> struct describe_field_t<SgVarRefExp,SgExpression*,&SgVarRefExp::p_originalExpressionTree> {
33072 using parent = SgVarRefExp;
33073 using field_type = SgExpression*;
33074 static constexpr size_t position{1};
33075 static constexpr char const * const name{"originalExpressionTree"};
33076 static constexpr char const * const typestr{"SgExpression*"};
33077 static constexpr bool traverse{false};
33078 static constexpr auto mbr_ptr{&SgVarRefExp::p_originalExpressionTree};
33079 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33080 using bind = Desc<SgVarRefExp, SgExpression* SgVarRefExp::*, &SgVarRefExp::p_originalExpressionTree>;
33081};
33082template <> struct describe_field_t<SgVarRefExp,int,&SgVarRefExp::p_name_qualification_length> {
33083 using parent = SgVarRefExp;
33084 using field_type = int;
33085 static constexpr size_t position{2};
33086 static constexpr char const * const name{"name_qualification_length"};
33087 static constexpr char const * const typestr{"int"};
33088 static constexpr bool traverse{false};
33089 static constexpr auto mbr_ptr{&SgVarRefExp::p_name_qualification_length};
33090 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33091 using bind = Desc<SgVarRefExp, int SgVarRefExp::*, &SgVarRefExp::p_name_qualification_length>;
33092};
33093template <> struct describe_field_t<SgVarRefExp,bool,&SgVarRefExp::p_type_elaboration_required> {
33094 using parent = SgVarRefExp;
33095 using field_type = bool;
33096 static constexpr size_t position{3};
33097 static constexpr char const * const name{"type_elaboration_required"};
33098 static constexpr char const * const typestr{"bool"};
33099 static constexpr bool traverse{false};
33100 static constexpr auto mbr_ptr{&SgVarRefExp::p_type_elaboration_required};
33101 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33102 using bind = Desc<SgVarRefExp, bool SgVarRefExp::*, &SgVarRefExp::p_type_elaboration_required>;
33103};
33104template <> struct describe_field_t<SgVarRefExp,bool,&SgVarRefExp::p_global_qualification_required> {
33105 using parent = SgVarRefExp;
33106 using field_type = bool;
33107 static constexpr size_t position{4};
33108 static constexpr char const * const name{"global_qualification_required"};
33109 static constexpr char const * const typestr{"bool"};
33110 static constexpr bool traverse{false};
33111 static constexpr auto mbr_ptr{&SgVarRefExp::p_global_qualification_required};
33112 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33113 using bind = Desc<SgVarRefExp, bool SgVarRefExp::*, &SgVarRefExp::p_global_qualification_required>;
33114};
33124template <> struct node_from_variant_t<838> { using type = SgVarRefExp; };
33125
33126// Class: VariableDeclaration
33130 static constexpr size_t position{0};
33131 static constexpr char const * const name{"baseTypeDefiningDeclaration"};
33132 static constexpr char const * const typestr{"SgDeclarationStatement*"};
33133 static constexpr bool traverse{true};
33134 static constexpr auto mbr_ptr{&SgVariableDeclaration::p_baseTypeDefiningDeclaration};
33135 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33136 using bind = Desc<SgVariableDeclaration, SgDeclarationStatement* SgVariableDeclaration::*, &SgVariableDeclaration::p_baseTypeDefiningDeclaration>;
33137};
33140 using field_type = SgInitializedNamePtrList;
33141 static constexpr size_t position{1};
33142 static constexpr char const * const name{"variables"};
33143 static constexpr char const * const typestr{"SgInitializedNamePtrList"};
33144 static constexpr bool traverse{true};
33145 static constexpr auto mbr_ptr{&SgVariableDeclaration::p_variables};
33146 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33147 using bind = Desc<SgVariableDeclaration, SgInitializedNamePtrList SgVariableDeclaration::*, &SgVariableDeclaration::p_variables>;
33148};
33151 using field_type = bool;
33152 static constexpr size_t position{2};
33153 static constexpr char const * const name{"variableDeclarationContainsBaseTypeDefiningDeclaration"};
33154 static constexpr char const * const typestr{"bool"};
33155 static constexpr bool traverse{false};
33157 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33158 using bind = Desc<SgVariableDeclaration, bool SgVariableDeclaration::*, &SgVariableDeclaration::p_variableDeclarationContainsBaseTypeDefiningDeclaration>;
33159};
33163 static constexpr size_t position{3};
33164 static constexpr char const * const name{"specialization"};
33165 static constexpr char const * const typestr{"SgDeclarationStatement::template_specialization_enum"};
33166 static constexpr bool traverse{false};
33167 static constexpr auto mbr_ptr{&SgVariableDeclaration::p_specialization};
33168 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33169 using bind = Desc<SgVariableDeclaration, SgDeclarationStatement::template_specialization_enum SgVariableDeclaration::*, &SgVariableDeclaration::p_specialization>;
33170};
33171template <> struct describe_field_t<SgVariableDeclaration,bool,&SgVariableDeclaration::p_requiresGlobalNameQualificationOnType> {
33173 using field_type = bool;
33174 static constexpr size_t position{4};
33175 static constexpr char const * const name{"requiresGlobalNameQualificationOnType"};
33176 static constexpr char const * const typestr{"bool"};
33177 static constexpr bool traverse{false};
33178 static constexpr auto mbr_ptr{&SgVariableDeclaration::p_requiresGlobalNameQualificationOnType};
33179 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33180 using bind = Desc<SgVariableDeclaration, bool SgVariableDeclaration::*, &SgVariableDeclaration::p_requiresGlobalNameQualificationOnType>;
33181};
33182template <> struct describe_field_t<SgVariableDeclaration,std::string,&SgVariableDeclaration::p_gnu_extension_section> {
33184 using field_type = std::string;
33185 static constexpr size_t position{5};
33186 static constexpr char const * const name{"gnu_extension_section"};
33187 static constexpr char const * const typestr{"std::string"};
33188 static constexpr bool traverse{false};
33189 static constexpr auto mbr_ptr{&SgVariableDeclaration::p_gnu_extension_section};
33190 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33191 using bind = Desc<SgVariableDeclaration, std::string SgVariableDeclaration::*, &SgVariableDeclaration::p_gnu_extension_section>;
33192};
33193template <> struct describe_field_t<SgVariableDeclaration,std::string,&SgVariableDeclaration::p_gnu_extension_alias> {
33195 using field_type = std::string;
33196 static constexpr size_t position{6};
33197 static constexpr char const * const name{"gnu_extension_alias"};
33198 static constexpr char const * const typestr{"std::string"};
33199 static constexpr bool traverse{false};
33200 static constexpr auto mbr_ptr{&SgVariableDeclaration::p_gnu_extension_alias};
33201 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33202 using bind = Desc<SgVariableDeclaration, std::string SgVariableDeclaration::*, &SgVariableDeclaration::p_gnu_extension_alias>;
33203};
33204template <> struct describe_field_t<SgVariableDeclaration,unsigned short,&SgVariableDeclaration::p_gnu_extension_initialization_priority> {
33206 using field_type = unsigned short;
33207 static constexpr size_t position{7};
33208 static constexpr char const * const name{"gnu_extension_initialization_priority"};
33209 static constexpr char const * const typestr{"unsigned short"};
33210 static constexpr bool traverse{false};
33211 static constexpr auto mbr_ptr{&SgVariableDeclaration::p_gnu_extension_initialization_priority};
33212 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33213 using bind = Desc<SgVariableDeclaration, unsigned short SgVariableDeclaration::*, &SgVariableDeclaration::p_gnu_extension_initialization_priority>;
33214};
33215template <> struct describe_field_t<SgVariableDeclaration,SgDeclarationStatement::gnu_extension_visability_attribute_enum,&SgVariableDeclaration::p_gnu_extension_visability> {
33218 static constexpr size_t position{8};
33219 static constexpr char const * const name{"gnu_extension_visability"};
33220 static constexpr char const * const typestr{"SgDeclarationStatement::gnu_extension_visability_attribute_enum"};
33221 static constexpr bool traverse{false};
33222 static constexpr auto mbr_ptr{&SgVariableDeclaration::p_gnu_extension_visability};
33223 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33224 using bind = Desc<SgVariableDeclaration, SgDeclarationStatement::gnu_extension_visability_attribute_enum SgVariableDeclaration::*, &SgVariableDeclaration::p_gnu_extension_visability>;
33225};
33226template <> struct describe_field_t<SgVariableDeclaration,SgVariableDeclaration::gnu_extension_declaration_attributes_enum,&SgVariableDeclaration::p_gnu_extension_declaration_attribute> {
33229 static constexpr size_t position{9};
33230 static constexpr char const * const name{"gnu_extension_declaration_attribute"};
33231 static constexpr char const * const typestr{"SgVariableDeclaration::gnu_extension_declaration_attributes_enum"};
33232 static constexpr bool traverse{false};
33233 static constexpr auto mbr_ptr{&SgVariableDeclaration::p_gnu_extension_declaration_attribute};
33234 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33235 using bind = Desc<SgVariableDeclaration, SgVariableDeclaration::gnu_extension_declaration_attributes_enum SgVariableDeclaration::*, &SgVariableDeclaration::p_gnu_extension_declaration_attribute>;
33236};
33237template <> struct describe_field_t<SgVariableDeclaration,int,&SgVariableDeclaration::p_name_qualification_length> {
33239 using field_type = int;
33240 static constexpr size_t position{10};
33241 static constexpr char const * const name{"name_qualification_length"};
33242 static constexpr char const * const typestr{"int"};
33243 static constexpr bool traverse{false};
33244 static constexpr auto mbr_ptr{&SgVariableDeclaration::p_name_qualification_length};
33245 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33246 using bind = Desc<SgVariableDeclaration, int SgVariableDeclaration::*, &SgVariableDeclaration::p_name_qualification_length>;
33247};
33248template <> struct describe_field_t<SgVariableDeclaration,bool,&SgVariableDeclaration::p_type_elaboration_required> {
33250 using field_type = bool;
33251 static constexpr size_t position{11};
33252 static constexpr char const * const name{"type_elaboration_required"};
33253 static constexpr char const * const typestr{"bool"};
33254 static constexpr bool traverse{false};
33255 static constexpr auto mbr_ptr{&SgVariableDeclaration::p_type_elaboration_required};
33256 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33257 using bind = Desc<SgVariableDeclaration, bool SgVariableDeclaration::*, &SgVariableDeclaration::p_type_elaboration_required>;
33258};
33259template <> struct describe_field_t<SgVariableDeclaration,bool,&SgVariableDeclaration::p_global_qualification_required> {
33261 using field_type = bool;
33262 static constexpr size_t position{12};
33263 static constexpr char const * const name{"global_qualification_required"};
33264 static constexpr char const * const typestr{"bool"};
33265 static constexpr bool traverse{false};
33266 static constexpr auto mbr_ptr{&SgVariableDeclaration::p_global_qualification_required};
33267 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33268 using bind = Desc<SgVariableDeclaration, bool SgVariableDeclaration::*, &SgVariableDeclaration::p_global_qualification_required>;
33269};
33270template <> struct describe_field_t<SgVariableDeclaration,bool,&SgVariableDeclaration::p_isAssociatedWithDeclarationList> {
33272 using field_type = bool;
33273 static constexpr size_t position{13};
33274 static constexpr char const * const name{"isAssociatedWithDeclarationList"};
33275 static constexpr char const * const typestr{"bool"};
33276 static constexpr bool traverse{false};
33277 static constexpr auto mbr_ptr{&SgVariableDeclaration::p_isAssociatedWithDeclarationList};
33278 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33279 using bind = Desc<SgVariableDeclaration, bool SgVariableDeclaration::*, &SgVariableDeclaration::p_isAssociatedWithDeclarationList>;
33280};
33281template <> struct describe_field_t<SgVariableDeclaration,bool,&SgVariableDeclaration::p_isFirstDeclarationOfDeclarationList> {
33283 using field_type = bool;
33284 static constexpr size_t position{14};
33285 static constexpr char const * const name{"isFirstDeclarationOfDeclarationList"};
33286 static constexpr char const * const typestr{"bool"};
33287 static constexpr bool traverse{false};
33288 static constexpr auto mbr_ptr{&SgVariableDeclaration::p_isFirstDeclarationOfDeclarationList};
33289 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33290 using bind = Desc<SgVariableDeclaration, bool SgVariableDeclaration::*, &SgVariableDeclaration::p_isFirstDeclarationOfDeclarationList>;
33291};
33292template <> struct describe_field_t<SgVariableDeclaration,bool,&SgVariableDeclaration::p_is_thread_local> {
33294 using field_type = bool;
33295 static constexpr size_t position{15};
33296 static constexpr char const * const name{"is_thread_local"};
33297 static constexpr char const * const typestr{"bool"};
33298 static constexpr bool traverse{false};
33299 static constexpr auto mbr_ptr{&SgVariableDeclaration::p_is_thread_local};
33300 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33301 using bind = Desc<SgVariableDeclaration, bool SgVariableDeclaration::*, &SgVariableDeclaration::p_is_thread_local>;
33302};
33303template <> struct describe_field_t<SgVariableDeclaration,bool,&SgVariableDeclaration::p_is_constexpr> {
33305 using field_type = bool;
33306 static constexpr size_t position{16};
33307 static constexpr char const * const name{"is_constexpr"};
33308 static constexpr char const * const typestr{"bool"};
33309 static constexpr bool traverse{false};
33310 static constexpr auto mbr_ptr{&SgVariableDeclaration::p_is_constexpr};
33311 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33312 using bind = Desc<SgVariableDeclaration, bool SgVariableDeclaration::*, &SgVariableDeclaration::p_is_constexpr>;
33313};
33314template <> struct describe_field_t<SgVariableDeclaration,bool,&SgVariableDeclaration::p_builtFromUseOnly> {
33316 using field_type = bool;
33317 static constexpr size_t position{17};
33318 static constexpr char const * const name{"builtFromUseOnly"};
33319 static constexpr char const * const typestr{"bool"};
33320 static constexpr bool traverse{false};
33321 static constexpr auto mbr_ptr{&SgVariableDeclaration::p_builtFromUseOnly};
33322 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33323 using bind = Desc<SgVariableDeclaration, bool SgVariableDeclaration::*, &SgVariableDeclaration::p_builtFromUseOnly>;
33324};
33328 static constexpr char const * const name{"VariableDeclaration"};
33329 static constexpr unsigned long variant{839};
33330 static constexpr bool concrete{true};
33332 using fields_t = mp::List<describe_field_t<SgVariableDeclaration,SgDeclarationStatement*,&SgVariableDeclaration::p_baseTypeDefiningDeclaration>, describe_field_t<SgVariableDeclaration,SgInitializedNamePtrList,&SgVariableDeclaration::p_variables>, describe_field_t<SgVariableDeclaration,bool,&SgVariableDeclaration::p_variableDeclarationContainsBaseTypeDefiningDeclaration>, describe_field_t<SgVariableDeclaration,SgDeclarationStatement::template_specialization_enum,&SgVariableDeclaration::p_specialization>, describe_field_t<SgVariableDeclaration,bool,&SgVariableDeclaration::p_requiresGlobalNameQualificationOnType>, describe_field_t<SgVariableDeclaration,std::string,&SgVariableDeclaration::p_gnu_extension_section>, describe_field_t<SgVariableDeclaration,std::string,&SgVariableDeclaration::p_gnu_extension_alias>, describe_field_t<SgVariableDeclaration,unsigned short,&SgVariableDeclaration::p_gnu_extension_initialization_priority>, describe_field_t<SgVariableDeclaration,SgDeclarationStatement::gnu_extension_visability_attribute_enum,&SgVariableDeclaration::p_gnu_extension_visability>, describe_field_t<SgVariableDeclaration,SgVariableDeclaration::gnu_extension_declaration_attributes_enum,&SgVariableDeclaration::p_gnu_extension_declaration_attribute>, describe_field_t<SgVariableDeclaration,int,&SgVariableDeclaration::p_name_qualification_length>, describe_field_t<SgVariableDeclaration,bool,&SgVariableDeclaration::p_type_elaboration_required>, describe_field_t<SgVariableDeclaration,bool,&SgVariableDeclaration::p_global_qualification_required>, describe_field_t<SgVariableDeclaration,bool,&SgVariableDeclaration::p_isAssociatedWithDeclarationList>, describe_field_t<SgVariableDeclaration,bool,&SgVariableDeclaration::p_isFirstDeclarationOfDeclarationList>, describe_field_t<SgVariableDeclaration,bool,&SgVariableDeclaration::p_is_thread_local>, describe_field_t<SgVariableDeclaration,bool,&SgVariableDeclaration::p_is_constexpr>, describe_field_t<SgVariableDeclaration,bool,&SgVariableDeclaration::p_builtFromUseOnly>>;
33333};
33334template <> struct node_from_variant_t<839> { using type = SgVariableDeclaration; };
33335
33336// Class: VariableDefinition
33340 static constexpr size_t position{0};
33341 static constexpr char const * const name{"vardefn"};
33342 static constexpr char const * const typestr{"SgInitializedName*"};
33343 static constexpr bool traverse{true};
33344 static constexpr auto mbr_ptr{&SgVariableDefinition::p_vardefn};
33345 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33346 using bind = Desc<SgVariableDefinition, SgInitializedName* SgVariableDefinition::*, &SgVariableDefinition::p_vardefn>;
33347};
33350 using field_type = SgExpression*;
33351 static constexpr size_t position{1};
33352 static constexpr char const * const name{"bitfield"};
33353 static constexpr char const * const typestr{"SgExpression*"};
33354 static constexpr bool traverse{true};
33355 static constexpr auto mbr_ptr{&SgVariableDefinition::p_bitfield};
33356 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33357 using bind = Desc<SgVariableDefinition, SgExpression* SgVariableDefinition::*, &SgVariableDefinition::p_bitfield>;
33358};
33360 using node = SgVariableDefinition;
33362 static constexpr char const * const name{"VariableDefinition"};
33363 static constexpr unsigned long variant{840};
33364 static constexpr bool concrete{true};
33365 using subclasses_t = mp::List<>;
33367};
33368template <> struct node_from_variant_t<840> { using type = SgVariableDefinition; };
33369
33370// Class: VariableSymbol
33371template <> struct describe_field_t<SgVariableSymbol,SgInitializedName*,&SgVariableSymbol::p_declaration> {
33372 using parent = SgVariableSymbol;
33374 static constexpr size_t position{0};
33375 static constexpr char const * const name{"declaration"};
33376 static constexpr char const * const typestr{"SgInitializedName*"};
33377 static constexpr bool traverse{false};
33378 static constexpr auto mbr_ptr{&SgVariableSymbol::p_declaration};
33379 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33380 using bind = Desc<SgVariableSymbol, SgInitializedName* SgVariableSymbol::*, &SgVariableSymbol::p_declaration>;
33381};
33383 using node = SgVariableSymbol;
33384 using base = SgSymbol;
33385 static constexpr char const * const name{"VariableSymbol"};
33386 static constexpr unsigned long variant{841};
33387 static constexpr bool concrete{true};
33390};
33391template <> struct node_from_variant_t<841> { using type = SgVariableSymbol; };
33392
33393// Class: VariantExpression
33395 using node = SgVariantExpression;
33396 using base = SgExpression;
33397 static constexpr char const * const name{"VariantExpression"};
33398 static constexpr unsigned long variant{842};
33399 static constexpr bool concrete{true};
33400 using subclasses_t = mp::List<>;
33401 using fields_t = mp::List<>;
33402};
33403template <> struct node_from_variant_t<842> { using type = SgVariantExpression; };
33404
33405// Class: VariantStatement
33407 using node = SgVariantStatement;
33408 using base = SgStatement;
33409 static constexpr char const * const name{"VariantStatement"};
33410 static constexpr unsigned long variant{843};
33411 static constexpr bool concrete{true};
33412 using subclasses_t = mp::List<>;
33413 using fields_t = mp::List<>;
33414};
33415template <> struct node_from_variant_t<843> { using type = SgVariantStatement; };
33416
33417// Class: VoidVal
33418template <> struct describe_node_t<SgVoidVal> {
33419 using node = SgVoidVal;
33420 using base = SgValueExp;
33421 static constexpr char const * const name{"VoidVal"};
33422 static constexpr unsigned long variant{844};
33423 static constexpr bool concrete{true};
33424 using subclasses_t = mp::List<>;
33425 using fields_t = mp::List<>;
33426};
33427template <> struct node_from_variant_t<844> { using type = SgVoidVal; };
33428
33429// Class: WaitStatement
33431 using node = SgWaitStatement;
33432 using base = SgIOStatement;
33433 static constexpr char const * const name{"WaitStatement"};
33434 static constexpr unsigned long variant{845};
33435 static constexpr bool concrete{true};
33436 using subclasses_t = mp::List<>;
33437 using fields_t = mp::List<>;
33438};
33439template <> struct node_from_variant_t<845> { using type = SgWaitStatement; };
33440
33441// Class: WarningDirectiveStatement
33445 static constexpr char const * const name{"WarningDirectiveStatement"};
33446 static constexpr unsigned long variant{846};
33447 static constexpr bool concrete{true};
33448 using subclasses_t = mp::List<>;
33449 using fields_t = mp::List<>;
33450};
33451template <> struct node_from_variant_t<846> { using type = SgWarningDirectiveStatement; };
33452
33453// Class: WithStatement
33454template <> struct describe_field_t<SgWithStatement,SgExpression*,&SgWithStatement::p_expression> {
33455 using parent = SgWithStatement;
33456 using field_type = SgExpression*;
33457 static constexpr size_t position{0};
33458 static constexpr char const * const name{"expression"};
33459 static constexpr char const * const typestr{"SgExpression*"};
33460 static constexpr bool traverse{true};
33461 static constexpr auto mbr_ptr{&SgWithStatement::p_expression};
33462 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33463 using bind = Desc<SgWithStatement, SgExpression* SgWithStatement::*, &SgWithStatement::p_expression>;
33464};
33465template <> struct describe_field_t<SgWithStatement,SgStatement*,&SgWithStatement::p_body> {
33466 using parent = SgWithStatement;
33467 using field_type = SgStatement*;
33468 static constexpr size_t position{1};
33469 static constexpr char const * const name{"body"};
33470 static constexpr char const * const typestr{"SgStatement*"};
33471 static constexpr bool traverse{true};
33472 static constexpr auto mbr_ptr{&SgWithStatement::p_body};
33473 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33474 using bind = Desc<SgWithStatement, SgStatement* SgWithStatement::*, &SgWithStatement::p_body>;
33475};
33477 using node = SgWithStatement;
33478 using base = SgStatement;
33479 static constexpr char const * const name{"WithStatement"};
33480 static constexpr unsigned long variant{847};
33481 static constexpr bool concrete{true};
33482 using subclasses_t = mp::List<>;
33484};
33485template <> struct node_from_variant_t<847> { using type = SgWithStatement; };
33486
33487// Class: WcharVal
33488template <> struct describe_field_t<SgWcharVal,unsigned long,&SgWcharVal::p_valueUL> {
33489 using parent = SgWcharVal;
33490 using field_type = unsigned long;
33491 static constexpr size_t position{0};
33492 static constexpr char const * const name{"valueUL"};
33493 static constexpr char const * const typestr{"unsigned long"};
33494 static constexpr bool traverse{false};
33495 static constexpr auto mbr_ptr{&SgWcharVal::p_valueUL};
33496 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33497 using bind = Desc<SgWcharVal, unsigned long SgWcharVal::*, &SgWcharVal::p_valueUL>;
33498};
33499template <> struct describe_field_t<SgWcharVal,std::string,&SgWcharVal::p_valueString> {
33500 using parent = SgWcharVal;
33501 using field_type = std::string;
33502 static constexpr size_t position{1};
33503 static constexpr char const * const name{"valueString"};
33504 static constexpr char const * const typestr{"std::string"};
33505 static constexpr bool traverse{false};
33506 static constexpr auto mbr_ptr{&SgWcharVal::p_valueString};
33507 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33508 using bind = Desc<SgWcharVal, std::string SgWcharVal::*, &SgWcharVal::p_valueString>;
33509};
33510template <> struct describe_node_t<SgWcharVal> {
33511 using node = SgWcharVal;
33512 using base = SgValueExp;
33513 static constexpr char const * const name{"WcharVal"};
33514 static constexpr unsigned long variant{848};
33515 static constexpr bool concrete{true};
33516 using subclasses_t = mp::List<>;
33518};
33519template <> struct node_from_variant_t<848> { using type = SgWcharVal; };
33520
33521// Class: WhereStatement
33522template <> struct describe_field_t<SgWhereStatement,SgExpression*,&SgWhereStatement::p_condition> {
33523 using parent = SgWhereStatement;
33524 using field_type = SgExpression*;
33525 static constexpr size_t position{0};
33526 static constexpr char const * const name{"condition"};
33527 static constexpr char const * const typestr{"SgExpression*"};
33528 static constexpr bool traverse{true};
33529 static constexpr auto mbr_ptr{&SgWhereStatement::p_condition};
33530 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33531 using bind = Desc<SgWhereStatement, SgExpression* SgWhereStatement::*, &SgWhereStatement::p_condition>;
33532};
33533template <> struct describe_field_t<SgWhereStatement,SgBasicBlock*,&SgWhereStatement::p_body> {
33534 using parent = SgWhereStatement;
33535 using field_type = SgBasicBlock*;
33536 static constexpr size_t position{1};
33537 static constexpr char const * const name{"body"};
33538 static constexpr char const * const typestr{"SgBasicBlock*"};
33539 static constexpr bool traverse{true};
33540 static constexpr auto mbr_ptr{&SgWhereStatement::p_body};
33541 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33542 using bind = Desc<SgWhereStatement, SgBasicBlock* SgWhereStatement::*, &SgWhereStatement::p_body>;
33543};
33544template <> struct describe_field_t<SgWhereStatement,SgElseWhereStatement*,&SgWhereStatement::p_elsewhere> {
33545 using parent = SgWhereStatement;
33547 static constexpr size_t position{2};
33548 static constexpr char const * const name{"elsewhere"};
33549 static constexpr char const * const typestr{"SgElseWhereStatement*"};
33550 static constexpr bool traverse{true};
33551 static constexpr auto mbr_ptr{&SgWhereStatement::p_elsewhere};
33552 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33553 using bind = Desc<SgWhereStatement, SgElseWhereStatement* SgWhereStatement::*, &SgWhereStatement::p_elsewhere>;
33554};
33555template <> struct describe_field_t<SgWhereStatement,SgLabelRefExp*,&SgWhereStatement::p_end_numeric_label> {
33556 using parent = SgWhereStatement;
33557 using field_type = SgLabelRefExp*;
33558 static constexpr size_t position{3};
33559 static constexpr char const * const name{"end_numeric_label"};
33560 static constexpr char const * const typestr{"SgLabelRefExp*"};
33561 static constexpr bool traverse{false};
33562 static constexpr auto mbr_ptr{&SgWhereStatement::p_end_numeric_label};
33563 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33564 using bind = Desc<SgWhereStatement, SgLabelRefExp* SgWhereStatement::*, &SgWhereStatement::p_end_numeric_label>;
33565};
33566template <> struct describe_field_t<SgWhereStatement,std::string,&SgWhereStatement::p_string_label> {
33567 using parent = SgWhereStatement;
33568 using field_type = std::string;
33569 static constexpr size_t position{4};
33570 static constexpr char const * const name{"string_label"};
33571 static constexpr char const * const typestr{"std::string"};
33572 static constexpr bool traverse{false};
33573 static constexpr auto mbr_ptr{&SgWhereStatement::p_string_label};
33574 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33575 using bind = Desc<SgWhereStatement, std::string SgWhereStatement::*, &SgWhereStatement::p_string_label>;
33576};
33577template <> struct describe_field_t<SgWhereStatement,bool,&SgWhereStatement::p_has_end_statement> {
33578 using parent = SgWhereStatement;
33579 using field_type = bool;
33580 static constexpr size_t position{5};
33581 static constexpr char const * const name{"has_end_statement"};
33582 static constexpr char const * const typestr{"bool"};
33583 static constexpr bool traverse{false};
33584 static constexpr auto mbr_ptr{&SgWhereStatement::p_has_end_statement};
33585 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33586 using bind = Desc<SgWhereStatement, bool SgWhereStatement::*, &SgWhereStatement::p_has_end_statement>;
33587};
33597template <> struct node_from_variant_t<849> { using type = SgWhereStatement; };
33598
33599// Class: WhileStmt
33601 using parent = SgWhileStmt;
33602 using field_type = SgStatement*;
33603 static constexpr size_t position{0};
33604 static constexpr char const * const name{"condition"};
33605 static constexpr char const * const typestr{"SgStatement*"};
33606 static constexpr bool traverse{true};
33607 static constexpr auto mbr_ptr{&SgWhileStmt::p_condition};
33608 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33609 using bind = Desc<SgWhileStmt, SgStatement* SgWhileStmt::*, &SgWhileStmt::p_condition>;
33610};
33612 using parent = SgWhileStmt;
33613 using field_type = SgStatement*;
33614 static constexpr size_t position{1};
33615 static constexpr char const * const name{"body"};
33616 static constexpr char const * const typestr{"SgStatement*"};
33617 static constexpr bool traverse{true};
33618 static constexpr auto mbr_ptr{&SgWhileStmt::p_body};
33619 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33620 using bind = Desc<SgWhileStmt, SgStatement* SgWhileStmt::*, &SgWhileStmt::p_body>;
33621};
33623 using parent = SgWhileStmt;
33624 using field_type = SgStatement*;
33625 static constexpr size_t position{2};
33626 static constexpr char const * const name{"else_body"};
33627 static constexpr char const * const typestr{"SgStatement*"};
33628 static constexpr bool traverse{true};
33629 static constexpr auto mbr_ptr{&SgWhileStmt::p_else_body};
33630 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33631 using bind = Desc<SgWhileStmt, SgStatement* SgWhileStmt::*, &SgWhileStmt::p_else_body>;
33632};
33633template <> struct describe_field_t<SgWhileStmt,SgLabelRefExp*,&SgWhileStmt::p_end_numeric_label> {
33634 using parent = SgWhileStmt;
33635 using field_type = SgLabelRefExp*;
33636 static constexpr size_t position{3};
33637 static constexpr char const * const name{"end_numeric_label"};
33638 static constexpr char const * const typestr{"SgLabelRefExp*"};
33639 static constexpr bool traverse{false};
33640 static constexpr auto mbr_ptr{&SgWhileStmt::p_end_numeric_label};
33641 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33642 using bind = Desc<SgWhileStmt, SgLabelRefExp* SgWhileStmt::*, &SgWhileStmt::p_end_numeric_label>;
33643};
33644template <> struct describe_field_t<SgWhileStmt,std::string,&SgWhileStmt::p_string_label> {
33645 using parent = SgWhileStmt;
33646 using field_type = std::string;
33647 static constexpr size_t position{4};
33648 static constexpr char const * const name{"string_label"};
33649 static constexpr char const * const typestr{"std::string"};
33650 static constexpr bool traverse{false};
33651 static constexpr auto mbr_ptr{&SgWhileStmt::p_string_label};
33652 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33653 using bind = Desc<SgWhileStmt, std::string SgWhileStmt::*, &SgWhileStmt::p_string_label>;
33654};
33655template <> struct describe_field_t<SgWhileStmt,bool,&SgWhileStmt::p_has_end_statement> {
33656 using parent = SgWhileStmt;
33657 using field_type = bool;
33658 static constexpr size_t position{5};
33659 static constexpr char const * const name{"has_end_statement"};
33660 static constexpr char const * const typestr{"bool"};
33661 static constexpr bool traverse{false};
33662 static constexpr auto mbr_ptr{&SgWhileStmt::p_has_end_statement};
33663 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33664 using bind = Desc<SgWhileStmt, bool SgWhileStmt::*, &SgWhileStmt::p_has_end_statement>;
33665};
33675template <> struct node_from_variant_t<850> { using type = SgWhileStmt; };
33676
33677// Class: WriteStatement
33678template <> struct describe_field_t<SgWriteStatement,SgExpression*,&SgWriteStatement::p_format> {
33679 using parent = SgWriteStatement;
33680 using field_type = SgExpression*;
33681 static constexpr size_t position{0};
33682 static constexpr char const * const name{"format"};
33683 static constexpr char const * const typestr{"SgExpression*"};
33684 static constexpr bool traverse{true};
33685 static constexpr auto mbr_ptr{&SgWriteStatement::p_format};
33686 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33687 using bind = Desc<SgWriteStatement, SgExpression* SgWriteStatement::*, &SgWriteStatement::p_format>;
33688};
33689template <> struct describe_field_t<SgWriteStatement,SgExpression*,&SgWriteStatement::p_namelist> {
33690 using parent = SgWriteStatement;
33691 using field_type = SgExpression*;
33692 static constexpr size_t position{1};
33693 static constexpr char const * const name{"namelist"};
33694 static constexpr char const * const typestr{"SgExpression*"};
33695 static constexpr bool traverse{true};
33696 static constexpr auto mbr_ptr{&SgWriteStatement::p_namelist};
33697 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33698 using bind = Desc<SgWriteStatement, SgExpression* SgWriteStatement::*, &SgWriteStatement::p_namelist>;
33699};
33700template <> struct describe_field_t<SgWriteStatement,SgExpression*,&SgWriteStatement::p_advance> {
33701 using parent = SgWriteStatement;
33702 using field_type = SgExpression*;
33703 static constexpr size_t position{2};
33704 static constexpr char const * const name{"advance"};
33705 static constexpr char const * const typestr{"SgExpression*"};
33706 static constexpr bool traverse{true};
33707 static constexpr auto mbr_ptr{&SgWriteStatement::p_advance};
33708 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33709 using bind = Desc<SgWriteStatement, SgExpression* SgWriteStatement::*, &SgWriteStatement::p_advance>;
33710};
33711template <> struct describe_field_t<SgWriteStatement,SgExpression*,&SgWriteStatement::p_asynchronous> {
33712 using parent = SgWriteStatement;
33713 using field_type = SgExpression*;
33714 static constexpr size_t position{3};
33715 static constexpr char const * const name{"asynchronous"};
33716 static constexpr char const * const typestr{"SgExpression*"};
33717 static constexpr bool traverse{true};
33718 static constexpr auto mbr_ptr{&SgWriteStatement::p_asynchronous};
33719 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33720 using bind = Desc<SgWriteStatement, SgExpression* SgWriteStatement::*, &SgWriteStatement::p_asynchronous>;
33721};
33722template <> struct describe_field_t<SgWriteStatement,SgExpression*,&SgWriteStatement::p_blank> {
33723 using parent = SgWriteStatement;
33724 using field_type = SgExpression*;
33725 static constexpr size_t position{4};
33726 static constexpr char const * const name{"blank"};
33727 static constexpr char const * const typestr{"SgExpression*"};
33728 static constexpr bool traverse{true};
33729 static constexpr auto mbr_ptr{&SgWriteStatement::p_blank};
33730 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33731 using bind = Desc<SgWriteStatement, SgExpression* SgWriteStatement::*, &SgWriteStatement::p_blank>;
33732};
33733template <> struct describe_field_t<SgWriteStatement,SgExpression*,&SgWriteStatement::p_decimal> {
33734 using parent = SgWriteStatement;
33735 using field_type = SgExpression*;
33736 static constexpr size_t position{5};
33737 static constexpr char const * const name{"decimal"};
33738 static constexpr char const * const typestr{"SgExpression*"};
33739 static constexpr bool traverse{true};
33740 static constexpr auto mbr_ptr{&SgWriteStatement::p_decimal};
33741 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33742 using bind = Desc<SgWriteStatement, SgExpression* SgWriteStatement::*, &SgWriteStatement::p_decimal>;
33743};
33744template <> struct describe_field_t<SgWriteStatement,SgExpression*,&SgWriteStatement::p_delim> {
33745 using parent = SgWriteStatement;
33746 using field_type = SgExpression*;
33747 static constexpr size_t position{6};
33748 static constexpr char const * const name{"delim"};
33749 static constexpr char const * const typestr{"SgExpression*"};
33750 static constexpr bool traverse{true};
33751 static constexpr auto mbr_ptr{&SgWriteStatement::p_delim};
33752 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33753 using bind = Desc<SgWriteStatement, SgExpression* SgWriteStatement::*, &SgWriteStatement::p_delim>;
33754};
33755template <> struct describe_field_t<SgWriteStatement,SgExpression*,&SgWriteStatement::p_end> {
33756 using parent = SgWriteStatement;
33757 using field_type = SgExpression*;
33758 static constexpr size_t position{7};
33759 static constexpr char const * const name{"end"};
33760 static constexpr char const * const typestr{"SgExpression*"};
33761 static constexpr bool traverse{true};
33762 static constexpr auto mbr_ptr{&SgWriteStatement::p_end};
33763 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33764 using bind = Desc<SgWriteStatement, SgExpression* SgWriteStatement::*, &SgWriteStatement::p_end>;
33765};
33766template <> struct describe_field_t<SgWriteStatement,SgExpression*,&SgWriteStatement::p_eor> {
33767 using parent = SgWriteStatement;
33768 using field_type = SgExpression*;
33769 static constexpr size_t position{8};
33770 static constexpr char const * const name{"eor"};
33771 static constexpr char const * const typestr{"SgExpression*"};
33772 static constexpr bool traverse{true};
33773 static constexpr auto mbr_ptr{&SgWriteStatement::p_eor};
33774 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33775 using bind = Desc<SgWriteStatement, SgExpression* SgWriteStatement::*, &SgWriteStatement::p_eor>;
33776};
33777template <> struct describe_field_t<SgWriteStatement,SgExpression*,&SgWriteStatement::p_id> {
33778 using parent = SgWriteStatement;
33779 using field_type = SgExpression*;
33780 static constexpr size_t position{9};
33781 static constexpr char const * const name{"id"};
33782 static constexpr char const * const typestr{"SgExpression*"};
33783 static constexpr bool traverse{true};
33784 static constexpr auto mbr_ptr{&SgWriteStatement::p_id};
33785 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33786 using bind = Desc<SgWriteStatement, SgExpression* SgWriteStatement::*, &SgWriteStatement::p_id>;
33787};
33788template <> struct describe_field_t<SgWriteStatement,SgExpression*,&SgWriteStatement::p_pad> {
33789 using parent = SgWriteStatement;
33790 using field_type = SgExpression*;
33791 static constexpr size_t position{10};
33792 static constexpr char const * const name{"pad"};
33793 static constexpr char const * const typestr{"SgExpression*"};
33794 static constexpr bool traverse{true};
33795 static constexpr auto mbr_ptr{&SgWriteStatement::p_pad};
33796 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33797 using bind = Desc<SgWriteStatement, SgExpression* SgWriteStatement::*, &SgWriteStatement::p_pad>;
33798};
33799template <> struct describe_field_t<SgWriteStatement,SgExpression*,&SgWriteStatement::p_pos> {
33800 using parent = SgWriteStatement;
33801 using field_type = SgExpression*;
33802 static constexpr size_t position{11};
33803 static constexpr char const * const name{"pos"};
33804 static constexpr char const * const typestr{"SgExpression*"};
33805 static constexpr bool traverse{true};
33806 static constexpr auto mbr_ptr{&SgWriteStatement::p_pos};
33807 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33808 using bind = Desc<SgWriteStatement, SgExpression* SgWriteStatement::*, &SgWriteStatement::p_pos>;
33809};
33810template <> struct describe_field_t<SgWriteStatement,SgExpression*,&SgWriteStatement::p_rec> {
33811 using parent = SgWriteStatement;
33812 using field_type = SgExpression*;
33813 static constexpr size_t position{12};
33814 static constexpr char const * const name{"rec"};
33815 static constexpr char const * const typestr{"SgExpression*"};
33816 static constexpr bool traverse{true};
33817 static constexpr auto mbr_ptr{&SgWriteStatement::p_rec};
33818 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33819 using bind = Desc<SgWriteStatement, SgExpression* SgWriteStatement::*, &SgWriteStatement::p_rec>;
33820};
33821template <> struct describe_field_t<SgWriteStatement,SgExpression*,&SgWriteStatement::p_round> {
33822 using parent = SgWriteStatement;
33823 using field_type = SgExpression*;
33824 static constexpr size_t position{13};
33825 static constexpr char const * const name{"round"};
33826 static constexpr char const * const typestr{"SgExpression*"};
33827 static constexpr bool traverse{true};
33828 static constexpr auto mbr_ptr{&SgWriteStatement::p_round};
33829 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33830 using bind = Desc<SgWriteStatement, SgExpression* SgWriteStatement::*, &SgWriteStatement::p_round>;
33831};
33832template <> struct describe_field_t<SgWriteStatement,SgExpression*,&SgWriteStatement::p_sign> {
33833 using parent = SgWriteStatement;
33834 using field_type = SgExpression*;
33835 static constexpr size_t position{14};
33836 static constexpr char const * const name{"sign"};
33837 static constexpr char const * const typestr{"SgExpression*"};
33838 static constexpr bool traverse{true};
33839 static constexpr auto mbr_ptr{&SgWriteStatement::p_sign};
33840 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33841 using bind = Desc<SgWriteStatement, SgExpression* SgWriteStatement::*, &SgWriteStatement::p_sign>;
33842};
33843template <> struct describe_field_t<SgWriteStatement,SgExpression*,&SgWriteStatement::p_size> {
33844 using parent = SgWriteStatement;
33845 using field_type = SgExpression*;
33846 static constexpr size_t position{15};
33847 static constexpr char const * const name{"size"};
33848 static constexpr char const * const typestr{"SgExpression*"};
33849 static constexpr bool traverse{true};
33850 static constexpr auto mbr_ptr{&SgWriteStatement::p_size};
33851 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33852 using bind = Desc<SgWriteStatement, SgExpression* SgWriteStatement::*, &SgWriteStatement::p_size>;
33853};
33855 using node = SgWriteStatement;
33856 using base = SgIOStatement;
33857 static constexpr char const * const name{"WriteStatement"};
33858 static constexpr unsigned long variant{851};
33859 static constexpr bool concrete{true};
33860 using subclasses_t = mp::List<>;
33862};
33863template <> struct node_from_variant_t<851> { using type = SgWriteStatement; };
33864
33865// Class: XorAssignOp
33866template <> struct describe_node_t<SgXorAssignOp> {
33867 using node = SgXorAssignOp;
33868 using base = SgCompoundAssignOp;
33869 static constexpr char const * const name{"XorAssignOp"};
33870 static constexpr unsigned long variant{852};
33871 static constexpr bool concrete{true};
33872 using subclasses_t = mp::List<>;
33873 using fields_t = mp::List<>;
33874};
33875template <> struct node_from_variant_t<852> { using type = SgXorAssignOp; };
33876
33877// Class: YieldExpression
33878template <> struct describe_field_t<SgYieldExpression,SgExpression*,&SgYieldExpression::p_value> {
33879 using parent = SgYieldExpression;
33880 using field_type = SgExpression*;
33881 static constexpr size_t position{0};
33882 static constexpr char const * const name{"value"};
33883 static constexpr char const * const typestr{"SgExpression*"};
33884 static constexpr bool traverse{true};
33885 static constexpr auto mbr_ptr{&SgYieldExpression::p_value};
33886 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33887 using bind = Desc<SgYieldExpression, SgExpression* SgYieldExpression::*, &SgYieldExpression::p_value>;
33888};
33890 using node = SgYieldExpression;
33891 using base = SgExpression;
33892 static constexpr char const * const name{"YieldExpression"};
33893 static constexpr unsigned long variant{853};
33894 static constexpr bool concrete{true};
33895 using subclasses_t = mp::List<>;
33897};
33898template <> struct node_from_variant_t<853> { using type = SgYieldExpression; };
33899
33900// Class: _File_Info
33902 using parent = Sg_File_Info;
33903 using field_type = int;
33904 static constexpr size_t position{0};
33905 static constexpr char const * const name{"file_id"};
33906 static constexpr char const * const typestr{"int"};
33907 static constexpr bool traverse{false};
33908 static constexpr auto mbr_ptr{&Sg_File_Info::p_file_id};
33909 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33910 using bind = Desc<Sg_File_Info, int Sg_File_Info::*, &Sg_File_Info::p_file_id>;
33911};
33913 using parent = Sg_File_Info;
33914 using field_type = int;
33915 static constexpr size_t position{1};
33916 static constexpr char const * const name{"line"};
33917 static constexpr char const * const typestr{"int"};
33918 static constexpr bool traverse{false};
33919 static constexpr auto mbr_ptr{&Sg_File_Info::p_line};
33920 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33921 using bind = Desc<Sg_File_Info, int Sg_File_Info::*, &Sg_File_Info::p_line>;
33922};
33924 using parent = Sg_File_Info;
33925 using field_type = int;
33926 static constexpr size_t position{2};
33927 static constexpr char const * const name{"col"};
33928 static constexpr char const * const typestr{"int"};
33929 static constexpr bool traverse{false};
33930 static constexpr auto mbr_ptr{&Sg_File_Info::p_col};
33931 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33932 using bind = Desc<Sg_File_Info, int Sg_File_Info::*, &Sg_File_Info::p_col>;
33933};
33935 using parent = Sg_File_Info;
33936 using field_type = unsigned int;
33937 static constexpr size_t position{3};
33938 static constexpr char const * const name{"classificationBitField"};
33939 static constexpr char const * const typestr{"unsigned int"};
33940 static constexpr bool traverse{false};
33941 static constexpr auto mbr_ptr{&Sg_File_Info::p_classificationBitField};
33942 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33943 using bind = Desc<Sg_File_Info, unsigned int Sg_File_Info::*, &Sg_File_Info::p_classificationBitField>;
33944};
33945template <> struct describe_field_t<Sg_File_Info,int,&Sg_File_Info::p_physical_file_id> {
33946 using parent = Sg_File_Info;
33947 using field_type = int;
33948 static constexpr size_t position{4};
33949 static constexpr char const * const name{"physical_file_id"};
33950 static constexpr char const * const typestr{"int"};
33951 static constexpr bool traverse{false};
33952 static constexpr auto mbr_ptr{&Sg_File_Info::p_physical_file_id};
33953 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33954 using bind = Desc<Sg_File_Info, int Sg_File_Info::*, &Sg_File_Info::p_physical_file_id>;
33955};
33956template <> struct describe_field_t<Sg_File_Info,int,&Sg_File_Info::p_physical_line> {
33957 using parent = Sg_File_Info;
33958 using field_type = int;
33959 static constexpr size_t position{5};
33960 static constexpr char const * const name{"physical_line"};
33961 static constexpr char const * const typestr{"int"};
33962 static constexpr bool traverse{false};
33963 static constexpr auto mbr_ptr{&Sg_File_Info::p_physical_line};
33964 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33965 using bind = Desc<Sg_File_Info, int Sg_File_Info::*, &Sg_File_Info::p_physical_line>;
33966};
33967template <> struct describe_field_t<Sg_File_Info,unsigned int,&Sg_File_Info::p_source_sequence_number> {
33968 using parent = Sg_File_Info;
33969 using field_type = unsigned int;
33970 static constexpr size_t position{6};
33971 static constexpr char const * const name{"source_sequence_number"};
33972 static constexpr char const * const typestr{"unsigned int"};
33973 static constexpr bool traverse{false};
33974 static constexpr auto mbr_ptr{&Sg_File_Info::p_source_sequence_number};
33975 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33976 using bind = Desc<Sg_File_Info, unsigned int Sg_File_Info::*, &Sg_File_Info::p_source_sequence_number>;
33977};
33979 using parent = Sg_File_Info;
33980 using field_type = SgFileIdList;
33981 static constexpr size_t position{7};
33982 static constexpr char const * const name{"fileIDsToUnparse"};
33983 static constexpr char const * const typestr{"SgFileIdList"};
33984 static constexpr bool traverse{false};
33985 static constexpr auto mbr_ptr{&Sg_File_Info::p_fileIDsToUnparse};
33986 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33987 using bind = Desc<Sg_File_Info, SgFileIdList Sg_File_Info::*, &Sg_File_Info::p_fileIDsToUnparse>;
33988};
33989template <> struct describe_field_t<Sg_File_Info,SgFileLineNumberList,&Sg_File_Info::p_fileLineNumbersToUnparse> {
33990 using parent = Sg_File_Info;
33991 using field_type = SgFileLineNumberList;
33992 static constexpr size_t position{8};
33993 static constexpr char const * const name{"fileLineNumbersToUnparse"};
33994 static constexpr char const * const typestr{"SgFileLineNumberList"};
33995 static constexpr bool traverse{false};
33996 static constexpr auto mbr_ptr{&Sg_File_Info::p_fileLineNumbersToUnparse};
33997 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33998 using bind = Desc<Sg_File_Info, SgFileLineNumberList Sg_File_Info::*, &Sg_File_Info::p_fileLineNumbersToUnparse>;
33999};
34009template <> struct node_from_variant_t<854> { using type = Sg_File_Info; };
34010
34011// Class: TypeCAFTeam
34012template <> struct describe_node_t<SgTypeCAFTeam> {
34013 using node = SgTypeCAFTeam;
34014 using base = SgType;
34015 static constexpr char const * const name{"TypeCAFTeam"};
34016 static constexpr unsigned long variant{855};
34017 static constexpr bool concrete{true};
34018 using subclasses_t = mp::List<>;
34019 using fields_t = mp::List<>;
34020};
34021template <> struct node_from_variant_t<855> { using type = SgTypeCAFTeam; };
34022
34023// Class: CAFWithTeamStatement
34024template <> struct describe_field_t<SgCAFWithTeamStatement,SgVarRefExp*,&SgCAFWithTeamStatement::p_teamId> {
34026 using field_type = SgVarRefExp*;
34027 static constexpr size_t position{0};
34028 static constexpr char const * const name{"teamId"};
34029 static constexpr char const * const typestr{"SgVarRefExp*"};
34030 static constexpr bool traverse{false};
34031 static constexpr auto mbr_ptr{&SgCAFWithTeamStatement::p_teamId};
34032 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34033 using bind = Desc<SgCAFWithTeamStatement, SgVarRefExp* SgCAFWithTeamStatement::*, &SgCAFWithTeamStatement::p_teamId>;
34034};
34035template <> struct describe_field_t<SgCAFWithTeamStatement,SgBasicBlock*,&SgCAFWithTeamStatement::p_body> {
34037 using field_type = SgBasicBlock*;
34038 static constexpr size_t position{1};
34039 static constexpr char const * const name{"body"};
34040 static constexpr char const * const typestr{"SgBasicBlock*"};
34041 static constexpr bool traverse{true};
34042 static constexpr auto mbr_ptr{&SgCAFWithTeamStatement::p_body};
34043 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34044 using bind = Desc<SgCAFWithTeamStatement, SgBasicBlock* SgCAFWithTeamStatement::*, &SgCAFWithTeamStatement::p_body>;
34045};
34046template <> struct describe_field_t<SgCAFWithTeamStatement,bool,&SgCAFWithTeamStatement::p_endHasTeamId> {
34048 using field_type = bool;
34049 static constexpr size_t position{2};
34050 static constexpr char const * const name{"endHasTeamId"};
34051 static constexpr char const * const typestr{"bool"};
34052 static constexpr bool traverse{false};
34053 static constexpr auto mbr_ptr{&SgCAFWithTeamStatement::p_endHasTeamId};
34054 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34055 using bind = Desc<SgCAFWithTeamStatement, bool SgCAFWithTeamStatement::*, &SgCAFWithTeamStatement::p_endHasTeamId>;
34056};
34059 using base = SgScopeStatement;
34060 static constexpr char const * const name{"CAFWithTeamStatement"};
34061 static constexpr unsigned long variant{856};
34062 static constexpr bool concrete{true};
34063 using subclasses_t = mp::List<>;
34065};
34066template <> struct node_from_variant_t<856> { using type = SgCAFWithTeamStatement; };
34067
34068// Class: CAFCoExpression
34069template <> struct describe_field_t<SgCAFCoExpression,SgVarRefExp*,&SgCAFCoExpression::p_teamId> {
34070 using parent = SgCAFCoExpression;
34071 using field_type = SgVarRefExp*;
34072 static constexpr size_t position{0};
34073 static constexpr char const * const name{"teamId"};
34074 static constexpr char const * const typestr{"SgVarRefExp*"};
34075 static constexpr bool traverse{false};
34076 static constexpr auto mbr_ptr{&SgCAFCoExpression::p_teamId};
34077 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34078 using bind = Desc<SgCAFCoExpression, SgVarRefExp* SgCAFCoExpression::*, &SgCAFCoExpression::p_teamId>;
34079};
34080template <> struct describe_field_t<SgCAFCoExpression,SgExpression*,&SgCAFCoExpression::p_teamRank> {
34081 using parent = SgCAFCoExpression;
34082 using field_type = SgExpression*;
34083 static constexpr size_t position{1};
34084 static constexpr char const * const name{"teamRank"};
34085 static constexpr char const * const typestr{"SgExpression*"};
34086 static constexpr bool traverse{false};
34087 static constexpr auto mbr_ptr{&SgCAFCoExpression::p_teamRank};
34088 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34089 using bind = Desc<SgCAFCoExpression, SgExpression* SgCAFCoExpression::*, &SgCAFCoExpression::p_teamRank>;
34090};
34091template <> struct describe_field_t<SgCAFCoExpression,SgExpression*,&SgCAFCoExpression::p_referData> {
34092 using parent = SgCAFCoExpression;
34093 using field_type = SgExpression*;
34094 static constexpr size_t position{2};
34095 static constexpr char const * const name{"referData"};
34096 static constexpr char const * const typestr{"SgExpression*"};
34097 static constexpr bool traverse{true};
34098 static constexpr auto mbr_ptr{&SgCAFCoExpression::p_referData};
34099 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34100 using bind = Desc<SgCAFCoExpression, SgExpression* SgCAFCoExpression::*, &SgCAFCoExpression::p_referData>;
34101};
34103 using node = SgCAFCoExpression;
34104 using base = SgExpression;
34105 static constexpr char const * const name{"CAFCoExpression"};
34106 static constexpr unsigned long variant{857};
34107 static constexpr bool concrete{true};
34108 using subclasses_t = mp::List<>;
34110};
34111template <> struct node_from_variant_t<857> { using type = SgCAFCoExpression; };
34112
34113// Class: CallExpression
34115 using parent = SgCallExpression;
34116 using field_type = SgExpression*;
34117 static constexpr size_t position{0};
34118 static constexpr char const * const name{"function"};
34119 static constexpr char const * const typestr{"SgExpression*"};
34120 static constexpr bool traverse{true};
34121 static constexpr auto mbr_ptr{&SgCallExpression::p_function};
34122 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34123 using bind = Desc<SgCallExpression, SgExpression* SgCallExpression::*, &SgCallExpression::p_function>;
34124};
34126 using parent = SgCallExpression;
34127 using field_type = SgExprListExp*;
34128 static constexpr size_t position{1};
34129 static constexpr char const * const name{"args"};
34130 static constexpr char const * const typestr{"SgExprListExp*"};
34131 static constexpr bool traverse{true};
34132 static constexpr auto mbr_ptr{&SgCallExpression::p_args};
34133 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34134 using bind = Desc<SgCallExpression, SgExprListExp* SgCallExpression::*, &SgCallExpression::p_args>;
34135};
34137 using parent = SgCallExpression;
34138 using field_type = SgType*;
34139 static constexpr size_t position{2};
34140 static constexpr char const * const name{"expression_type"};
34141 static constexpr char const * const typestr{"SgType*"};
34142 static constexpr bool traverse{false};
34143 static constexpr auto mbr_ptr{&SgCallExpression::p_expression_type};
34144 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34145 using bind = Desc<SgCallExpression, SgType* SgCallExpression::*, &SgCallExpression::p_expression_type>;
34146};
34148 using node = SgCallExpression;
34149 using base = SgExpression;
34150 static constexpr char const * const name{"CallExpression"};
34151 static constexpr unsigned long variant{858};
34152 static constexpr bool concrete{true};
34155};
34156template <> struct node_from_variant_t<858> { using type = SgCallExpression; };
34157
34158// Class: TypeCrayPointer
34160 using node = SgTypeCrayPointer;
34161 using base = SgType;
34162 static constexpr char const * const name{"TypeCrayPointer"};
34163 static constexpr unsigned long variant{859};
34164 static constexpr bool concrete{true};
34165 using subclasses_t = mp::List<>;
34166 using fields_t = mp::List<>;
34167};
34168template <> struct node_from_variant_t<859> { using type = SgTypeCrayPointer; };
34169
34170// Class: JavaImportStatement
34171template <> struct describe_field_t<SgJavaImportStatement,SgName,&SgJavaImportStatement::p_path> {
34173 using field_type = SgName;
34174 static constexpr size_t position{0};
34175 static constexpr char const * const name{"path"};
34176 static constexpr char const * const typestr{"SgName"};
34177 static constexpr bool traverse{false};
34178 static constexpr auto mbr_ptr{&SgJavaImportStatement::p_path};
34179 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34180 using bind = Desc<SgJavaImportStatement, SgName SgJavaImportStatement::*, &SgJavaImportStatement::p_path>;
34181};
34182template <> struct describe_field_t<SgJavaImportStatement,bool,&SgJavaImportStatement::p_containsWildCard> {
34184 using field_type = bool;
34185 static constexpr size_t position{1};
34186 static constexpr char const * const name{"containsWildCard"};
34187 static constexpr char const * const typestr{"bool"};
34188 static constexpr bool traverse{false};
34189 static constexpr auto mbr_ptr{&SgJavaImportStatement::p_containsWildCard};
34190 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34191 using bind = Desc<SgJavaImportStatement, bool SgJavaImportStatement::*, &SgJavaImportStatement::p_containsWildCard>;
34192};
34196 static constexpr char const * const name{"JavaImportStatement"};
34197 static constexpr unsigned long variant{860};
34198 static constexpr bool concrete{true};
34199 using subclasses_t = mp::List<>;
34201};
34202template <> struct node_from_variant_t<860> { using type = SgJavaImportStatement; };
34203
34204// Class: JavaPackageDeclaration
34207 using base = SgClassDeclaration;
34208 static constexpr char const * const name{"JavaPackageDeclaration"};
34209 static constexpr unsigned long variant{861};
34210 static constexpr bool concrete{true};
34211 using subclasses_t = mp::List<>;
34212 using fields_t = mp::List<>;
34213};
34214template <> struct node_from_variant_t<861> { using type = SgJavaPackageDeclaration; };
34215
34216// Class: JavaPackageStatement
34217template <> struct describe_field_t<SgJavaPackageStatement,SgName,&SgJavaPackageStatement::p_name> {
34219 using field_type = SgName;
34220 static constexpr size_t position{0};
34221 static constexpr char const * const name{"name"};
34222 static constexpr char const * const typestr{"SgName"};
34223 static constexpr bool traverse{false};
34224 static constexpr auto mbr_ptr{&SgJavaPackageStatement::p_name};
34225 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34226 using bind = Desc<SgJavaPackageStatement, SgName SgJavaPackageStatement::*, &SgJavaPackageStatement::p_name>;
34227};
34231 static constexpr char const * const name{"JavaPackageStatement"};
34232 static constexpr unsigned long variant{862};
34233 static constexpr bool concrete{true};
34234 using subclasses_t = mp::List<>;
34236};
34237template <> struct node_from_variant_t<862> { using type = SgJavaPackageStatement; };
34238
34239// Class: JavaImportStatementList
34240template <> struct describe_field_t<SgJavaImportStatementList,SgJavaImportStatementPtrList,&SgJavaImportStatementList::p_java_import_list> {
34242 using field_type = SgJavaImportStatementPtrList;
34243 static constexpr size_t position{0};
34244 static constexpr char const * const name{"java_import_list"};
34245 static constexpr char const * const typestr{"SgJavaImportStatementPtrList"};
34246 static constexpr bool traverse{true};
34247 static constexpr auto mbr_ptr{&SgJavaImportStatementList::p_java_import_list};
34248 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34249 using bind = Desc<SgJavaImportStatementList, SgJavaImportStatementPtrList SgJavaImportStatementList::*, &SgJavaImportStatementList::p_java_import_list>;
34250};
34253 using base = SgSupport;
34254 static constexpr char const * const name{"JavaImportStatementList"};
34255 static constexpr unsigned long variant{863};
34256 static constexpr bool concrete{true};
34257 using subclasses_t = mp::List<>;
34259};
34260template <> struct node_from_variant_t<863> { using type = SgJavaImportStatementList; };
34261
34262// Class: JavaClassDeclarationList
34263template <> struct describe_field_t<SgJavaClassDeclarationList,SgClassDeclarationPtrList,&SgJavaClassDeclarationList::p_java_class_list> {
34265 using field_type = SgClassDeclarationPtrList;
34266 static constexpr size_t position{0};
34267 static constexpr char const * const name{"java_class_list"};
34268 static constexpr char const * const typestr{"SgClassDeclarationPtrList"};
34269 static constexpr bool traverse{true};
34270 static constexpr auto mbr_ptr{&SgJavaClassDeclarationList::p_java_class_list};
34271 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34272 using bind = Desc<SgJavaClassDeclarationList, SgClassDeclarationPtrList SgJavaClassDeclarationList::*, &SgJavaClassDeclarationList::p_java_class_list>;
34273};
34276 using base = SgSupport;
34277 static constexpr char const * const name{"JavaClassDeclarationList"};
34278 static constexpr unsigned long variant{864};
34279 static constexpr bool concrete{true};
34280 using subclasses_t = mp::List<>;
34282};
34283template <> struct node_from_variant_t<864> { using type = SgJavaClassDeclarationList; };
34284
34285// Class: JavaMemberValuePair
34286template <> struct describe_field_t<SgJavaMemberValuePair,SgName,&SgJavaMemberValuePair::p_name> {
34288 using field_type = SgName;
34289 static constexpr size_t position{0};
34290 static constexpr char const * const name{"name"};
34291 static constexpr char const * const typestr{"SgName"};
34292 static constexpr bool traverse{false};
34293 static constexpr auto mbr_ptr{&SgJavaMemberValuePair::p_name};
34294 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34295 using bind = Desc<SgJavaMemberValuePair, SgName SgJavaMemberValuePair::*, &SgJavaMemberValuePair::p_name>;
34296};
34297template <> struct describe_field_t<SgJavaMemberValuePair,SgExpression*,&SgJavaMemberValuePair::p_value> {
34299 using field_type = SgExpression*;
34300 static constexpr size_t position{1};
34301 static constexpr char const * const name{"value"};
34302 static constexpr char const * const typestr{"SgExpression*"};
34303 static constexpr bool traverse{true};
34304 static constexpr auto mbr_ptr{&SgJavaMemberValuePair::p_value};
34305 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34306 using bind = Desc<SgJavaMemberValuePair, SgExpression* SgJavaMemberValuePair::*, &SgJavaMemberValuePair::p_value>;
34307};
34310 using base = SgLocatedNodeSupport;
34311 static constexpr char const * const name{"JavaMemberValuePair"};
34312 static constexpr unsigned long variant{865};
34313 static constexpr bool concrete{true};
34314 using subclasses_t = mp::List<>;
34316};
34317template <> struct node_from_variant_t<865> { using type = SgJavaMemberValuePair; };
34318
34319// Class: JavaAnnotation
34320template <> struct describe_field_t<SgJavaAnnotation,SgType*,&SgJavaAnnotation::p_expression_type> {
34321 using parent = SgJavaAnnotation;
34322 using field_type = SgType*;
34323 static constexpr size_t position{0};
34324 static constexpr char const * const name{"expression_type"};
34325 static constexpr char const * const typestr{"SgType*"};
34326 static constexpr bool traverse{false};
34327 static constexpr auto mbr_ptr{&SgJavaAnnotation::p_expression_type};
34328 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34329 using bind = Desc<SgJavaAnnotation, SgType* SgJavaAnnotation::*, &SgJavaAnnotation::p_expression_type>;
34330};
34332 using node = SgJavaAnnotation;
34333 using base = SgExpression;
34334 static constexpr char const * const name{"JavaAnnotation"};
34335 static constexpr unsigned long variant{866};
34336 static constexpr bool concrete{false};
34339};
34340template <> struct node_from_variant_t<866> { using type = SgJavaAnnotation; };
34341
34342// Class: JavaMarkerAnnotation
34345 using base = SgJavaAnnotation;
34346 static constexpr char const * const name{"JavaMarkerAnnotation"};
34347 static constexpr unsigned long variant{867};
34348 static constexpr bool concrete{true};
34349 using subclasses_t = mp::List<>;
34350 using fields_t = mp::List<>;
34351};
34352template <> struct node_from_variant_t<867> { using type = SgJavaMarkerAnnotation; };
34353
34354// Class: JavaSingleMemberAnnotation
34355template <> struct describe_field_t<SgJavaSingleMemberAnnotation,SgExpression*,&SgJavaSingleMemberAnnotation::p_value> {
34357 using field_type = SgExpression*;
34358 static constexpr size_t position{0};
34359 static constexpr char const * const name{"value"};
34360 static constexpr char const * const typestr{"SgExpression*"};
34361 static constexpr bool traverse{true};
34362 static constexpr auto mbr_ptr{&SgJavaSingleMemberAnnotation::p_value};
34363 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34364 using bind = Desc<SgJavaSingleMemberAnnotation, SgExpression* SgJavaSingleMemberAnnotation::*, &SgJavaSingleMemberAnnotation::p_value>;
34365};
34368 using base = SgJavaAnnotation;
34369 static constexpr char const * const name{"JavaSingleMemberAnnotation"};
34370 static constexpr unsigned long variant{868};
34371 static constexpr bool concrete{true};
34372 using subclasses_t = mp::List<>;
34374};
34375template <> struct node_from_variant_t<868> { using type = SgJavaSingleMemberAnnotation; };
34376
34377// Class: JavaNormalAnnotation
34378template <> struct describe_field_t<SgJavaNormalAnnotation,SgJavaMemberValuePairPtrList,&SgJavaNormalAnnotation::p_value_pair_list> {
34380 using field_type = SgJavaMemberValuePairPtrList;
34381 static constexpr size_t position{0};
34382 static constexpr char const * const name{"value_pair_list"};
34383 static constexpr char const * const typestr{"SgJavaMemberValuePairPtrList"};
34384 static constexpr bool traverse{true};
34385 static constexpr auto mbr_ptr{&SgJavaNormalAnnotation::p_value_pair_list};
34386 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34387 using bind = Desc<SgJavaNormalAnnotation, SgJavaMemberValuePairPtrList SgJavaNormalAnnotation::*, &SgJavaNormalAnnotation::p_value_pair_list>;
34388};
34391 using base = SgJavaAnnotation;
34392 static constexpr char const * const name{"JavaNormalAnnotation"};
34393 static constexpr unsigned long variant{869};
34394 static constexpr bool concrete{true};
34395 using subclasses_t = mp::List<>;
34397};
34398template <> struct node_from_variant_t<869> { using type = SgJavaNormalAnnotation; };
34399
34400// Class: JavaTypeExpression
34401template <> struct describe_field_t<SgJavaTypeExpression,SgType*,&SgJavaTypeExpression::p_type> {
34403 using field_type = SgType*;
34404 static constexpr size_t position{0};
34405 static constexpr char const * const name{"type"};
34406 static constexpr char const * const typestr{"SgType*"};
34407 static constexpr bool traverse{false};
34408 static constexpr auto mbr_ptr{&SgJavaTypeExpression::p_type};
34409 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34410 using bind = Desc<SgJavaTypeExpression, SgType* SgJavaTypeExpression::*, &SgJavaTypeExpression::p_type>;
34411};
34413 using node = SgJavaTypeExpression;
34414 using base = SgExpression;
34415 static constexpr char const * const name{"JavaTypeExpression"};
34416 static constexpr unsigned long variant{870};
34417 static constexpr bool concrete{true};
34418 using subclasses_t = mp::List<>;
34420};
34421template <> struct node_from_variant_t<870> { using type = SgJavaTypeExpression; };
34422
34423// Class: JavaQualifiedType
34424template <> struct describe_field_t<SgJavaQualifiedType,SgNamedType *,&SgJavaQualifiedType::p_parent_type> {
34426 using field_type = SgNamedType *;
34427 static constexpr size_t position{0};
34428 static constexpr char const * const name{"parent_type"};
34429 static constexpr char const * const typestr{"SgNamedType *"};
34430 static constexpr bool traverse{false};
34431 static constexpr auto mbr_ptr{&SgJavaQualifiedType::p_parent_type};
34432 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34433 using bind = Desc<SgJavaQualifiedType, SgNamedType * SgJavaQualifiedType::*, &SgJavaQualifiedType::p_parent_type>;
34434};
34435template <> struct describe_field_t<SgJavaQualifiedType,SgNamedType *,&SgJavaQualifiedType::p_type> {
34437 using field_type = SgNamedType *;
34438 static constexpr size_t position{1};
34439 static constexpr char const * const name{"type"};
34440 static constexpr char const * const typestr{"SgNamedType *"};
34441 static constexpr bool traverse{false};
34442 static constexpr auto mbr_ptr{&SgJavaQualifiedType::p_type};
34443 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34444 using bind = Desc<SgJavaQualifiedType, SgNamedType * SgJavaQualifiedType::*, &SgJavaQualifiedType::p_type>;
34445};
34447 using node = SgJavaQualifiedType;
34448 using base = SgNamedType;
34449 static constexpr char const * const name{"JavaQualifiedType"};
34450 static constexpr unsigned long variant{871};
34451 static constexpr bool concrete{true};
34452 using subclasses_t = mp::List<>;
34454};
34455template <> struct node_from_variant_t<871> { using type = SgJavaQualifiedType; };
34456
34457// Class: ClassExp
34458template <> struct describe_field_t<SgClassExp,SgClassSymbol*,&SgClassExp::p_class_symbol> {
34459 using parent = SgClassExp;
34460 using field_type = SgClassSymbol*;
34461 static constexpr size_t position{0};
34462 static constexpr char const * const name{"class_symbol"};
34463 static constexpr char const * const typestr{"SgClassSymbol*"};
34464 static constexpr bool traverse{false};
34465 static constexpr auto mbr_ptr{&SgClassExp::p_class_symbol};
34466 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34467 using bind = Desc<SgClassExp, SgClassSymbol* SgClassExp::*, &SgClassExp::p_class_symbol>;
34468};
34469template <> struct describe_field_t<SgClassExp,int,&SgClassExp::p_pobj_class> {
34470 using parent = SgClassExp;
34471 using field_type = int;
34472 static constexpr size_t position{1};
34473 static constexpr char const * const name{"pobj_class"};
34474 static constexpr char const * const typestr{"int"};
34475 static constexpr bool traverse{false};
34476 static constexpr auto mbr_ptr{&SgClassExp::p_pobj_class};
34477 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34478 using bind = Desc<SgClassExp, int SgClassExp::*, &SgClassExp::p_pobj_class>;
34479};
34480template <> struct describe_node_t<SgClassExp> {
34481 using node = SgClassExp;
34482 using base = SgExpression;
34483 static constexpr char const * const name{"ClassExp"};
34484 static constexpr unsigned long variant{872};
34485 static constexpr bool concrete{true};
34486 using subclasses_t = mp::List<>;
34488};
34489template <> struct node_from_variant_t<872> { using type = SgClassExp; };
34490
34491// Class: JavaUnionType
34492template <> struct describe_field_t<SgJavaUnionType,SgTypePtrList,&SgJavaUnionType::p_type_list> {
34493 using parent = SgJavaUnionType;
34494 using field_type = SgTypePtrList;
34495 static constexpr size_t position{0};
34496 static constexpr char const * const name{"type_list"};
34497 static constexpr char const * const typestr{"SgTypePtrList"};
34498 static constexpr bool traverse{false};
34499 static constexpr auto mbr_ptr{&SgJavaUnionType::p_type_list};
34500 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34501 using bind = Desc<SgJavaUnionType, SgTypePtrList SgJavaUnionType::*, &SgJavaUnionType::p_type_list>;
34502};
34504 using node = SgJavaUnionType;
34505 using base = SgType;
34506 static constexpr char const * const name{"JavaUnionType"};
34507 static constexpr unsigned long variant{873};
34508 static constexpr bool concrete{true};
34509 using subclasses_t = mp::List<>;
34511};
34512template <> struct node_from_variant_t<873> { using type = SgJavaUnionType; };
34513
34514// Class: JavaParameterType
34516 using node = SgJavaParameterType;
34517 using base = SgClassType;
34518 static constexpr char const * const name{"JavaParameterType"};
34519 static constexpr unsigned long variant{874};
34520 static constexpr bool concrete{true};
34521 using subclasses_t = mp::List<>;
34522 using fields_t = mp::List<>;
34523};
34524template <> struct node_from_variant_t<874> { using type = SgJavaParameterType; };
34525
34526// Class: AsyncStmt
34527template <> struct describe_field_t<SgAsyncStmt,SgStatement*,&SgAsyncStmt::p_body> {
34528 using parent = SgAsyncStmt;
34529 using field_type = SgStatement*;
34530 static constexpr size_t position{0};
34531 static constexpr char const * const name{"body"};
34532 static constexpr char const * const typestr{"SgStatement*"};
34533 static constexpr bool traverse{true};
34534 static constexpr auto mbr_ptr{&SgAsyncStmt::p_body};
34535 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34536 using bind = Desc<SgAsyncStmt, SgStatement* SgAsyncStmt::*, &SgAsyncStmt::p_body>;
34537};
34538template <> struct describe_node_t<SgAsyncStmt> {
34539 using node = SgAsyncStmt;
34540 using base = SgStatement;
34541 static constexpr char const * const name{"AsyncStmt"};
34542 static constexpr unsigned long variant{875};
34543 static constexpr bool concrete{true};
34544 using subclasses_t = mp::List<>;
34546};
34547template <> struct node_from_variant_t<875> { using type = SgAsyncStmt; };
34548
34549// Class: FinishStmt
34550template <> struct describe_field_t<SgFinishStmt,SgStatement*,&SgFinishStmt::p_body> {
34551 using parent = SgFinishStmt;
34552 using field_type = SgStatement*;
34553 static constexpr size_t position{0};
34554 static constexpr char const * const name{"body"};
34555 static constexpr char const * const typestr{"SgStatement*"};
34556 static constexpr bool traverse{true};
34557 static constexpr auto mbr_ptr{&SgFinishStmt::p_body};
34558 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34559 using bind = Desc<SgFinishStmt, SgStatement* SgFinishStmt::*, &SgFinishStmt::p_body>;
34560};
34561template <> struct describe_node_t<SgFinishStmt> {
34562 using node = SgFinishStmt;
34563 using base = SgStatement;
34564 static constexpr char const * const name{"FinishStmt"};
34565 static constexpr unsigned long variant{876};
34566 static constexpr bool concrete{true};
34567 using subclasses_t = mp::List<>;
34569};
34570template <> struct node_from_variant_t<876> { using type = SgFinishStmt; };
34571
34572// Class: AtStmt
34573template <> struct describe_field_t<SgAtStmt,SgExpression*,&SgAtStmt::p_expression> {
34574 using parent = SgAtStmt;
34575 using field_type = SgExpression*;
34576 static constexpr size_t position{0};
34577 static constexpr char const * const name{"expression"};
34578 static constexpr char const * const typestr{"SgExpression*"};
34579 static constexpr bool traverse{true};
34580 static constexpr auto mbr_ptr{&SgAtStmt::p_expression};
34581 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34582 using bind = Desc<SgAtStmt, SgExpression* SgAtStmt::*, &SgAtStmt::p_expression>;
34583};
34584template <> struct describe_field_t<SgAtStmt,SgStatement*,&SgAtStmt::p_body> {
34585 using parent = SgAtStmt;
34586 using field_type = SgStatement*;
34587 static constexpr size_t position{1};
34588 static constexpr char const * const name{"body"};
34589 static constexpr char const * const typestr{"SgStatement*"};
34590 static constexpr bool traverse{true};
34591 static constexpr auto mbr_ptr{&SgAtStmt::p_body};
34592 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34593 using bind = Desc<SgAtStmt, SgStatement* SgAtStmt::*, &SgAtStmt::p_body>;
34594};
34595template <> struct describe_node_t<SgAtStmt> {
34596 using node = SgAtStmt;
34597 using base = SgStatement;
34598 static constexpr char const * const name{"AtStmt"};
34599 static constexpr unsigned long variant{877};
34600 static constexpr bool concrete{true};
34601 using subclasses_t = mp::List<>;
34603};
34604template <> struct node_from_variant_t<877> { using type = SgAtStmt; };
34605
34606// Class: AtomicStmt
34607template <> struct describe_field_t<SgAtomicStmt,SgStatement*,&SgAtomicStmt::p_body> {
34608 using parent = SgAtomicStmt;
34609 using field_type = SgStatement*;
34610 static constexpr size_t position{0};
34611 static constexpr char const * const name{"body"};
34612 static constexpr char const * const typestr{"SgStatement*"};
34613 static constexpr bool traverse{true};
34614 static constexpr auto mbr_ptr{&SgAtomicStmt::p_body};
34615 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34616 using bind = Desc<SgAtomicStmt, SgStatement* SgAtomicStmt::*, &SgAtomicStmt::p_body>;
34617};
34618template <> struct describe_node_t<SgAtomicStmt> {
34619 using node = SgAtomicStmt;
34620 using base = SgStatement;
34621 static constexpr char const * const name{"AtomicStmt"};
34622 static constexpr unsigned long variant{878};
34623 static constexpr bool concrete{true};
34624 using subclasses_t = mp::List<>;
34626};
34627template <> struct node_from_variant_t<878> { using type = SgAtomicStmt; };
34628
34629// Class: WhenStmt
34630template <> struct describe_field_t<SgWhenStmt,SgExpression*,&SgWhenStmt::p_expression> {
34631 using parent = SgWhenStmt;
34632 using field_type = SgExpression*;
34633 static constexpr size_t position{0};
34634 static constexpr char const * const name{"expression"};
34635 static constexpr char const * const typestr{"SgExpression*"};
34636 static constexpr bool traverse{true};
34637 static constexpr auto mbr_ptr{&SgWhenStmt::p_expression};
34638 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34639 using bind = Desc<SgWhenStmt, SgExpression* SgWhenStmt::*, &SgWhenStmt::p_expression>;
34640};
34641template <> struct describe_field_t<SgWhenStmt,SgStatement*,&SgWhenStmt::p_body> {
34642 using parent = SgWhenStmt;
34643 using field_type = SgStatement*;
34644 static constexpr size_t position{1};
34645 static constexpr char const * const name{"body"};
34646 static constexpr char const * const typestr{"SgStatement*"};
34647 static constexpr bool traverse{true};
34648 static constexpr auto mbr_ptr{&SgWhenStmt::p_body};
34649 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34650 using bind = Desc<SgWhenStmt, SgStatement* SgWhenStmt::*, &SgWhenStmt::p_body>;
34651};
34652template <> struct describe_node_t<SgWhenStmt> {
34653 using node = SgWhenStmt;
34654 using base = SgStatement;
34655 static constexpr char const * const name{"WhenStmt"};
34656 static constexpr unsigned long variant{880};
34657 static constexpr bool concrete{true};
34658 using subclasses_t = mp::List<>;
34660};
34661template <> struct node_from_variant_t<880> { using type = SgWhenStmt; };
34662
34663// Class: AtExp
34664template <> struct describe_field_t<SgAtExp,SgExpression*,&SgAtExp::p_expression> {
34665 using parent = SgAtExp;
34666 using field_type = SgExpression*;
34667 static constexpr size_t position{0};
34668 static constexpr char const * const name{"expression"};
34669 static constexpr char const * const typestr{"SgExpression*"};
34670 static constexpr bool traverse{true};
34671 static constexpr auto mbr_ptr{&SgAtExp::p_expression};
34672 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34673 using bind = Desc<SgAtExp, SgExpression* SgAtExp::*, &SgAtExp::p_expression>;
34674};
34675template <> struct describe_field_t<SgAtExp,SgStatement*,&SgAtExp::p_body> {
34676 using parent = SgAtExp;
34677 using field_type = SgStatement*;
34678 static constexpr size_t position{1};
34679 static constexpr char const * const name{"body"};
34680 static constexpr char const * const typestr{"SgStatement*"};
34681 static constexpr bool traverse{true};
34682 static constexpr auto mbr_ptr{&SgAtExp::p_body};
34683 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34684 using bind = Desc<SgAtExp, SgStatement* SgAtExp::*, &SgAtExp::p_body>;
34685};
34686template <> struct describe_node_t<SgAtExp> {
34687 using node = SgAtExp;
34688 using base = SgExpression;
34689 static constexpr char const * const name{"AtExp"};
34690 static constexpr unsigned long variant{881};
34691 static constexpr bool concrete{true};
34692 using subclasses_t = mp::List<>;
34694};
34695template <> struct node_from_variant_t<881> { using type = SgAtExp; };
34696
34697// Class: FinishExp
34698template <> struct describe_field_t<SgFinishExp,SgExpression*,&SgFinishExp::p_expression> {
34699 using parent = SgFinishExp;
34700 using field_type = SgExpression*;
34701 static constexpr size_t position{0};
34702 static constexpr char const * const name{"expression"};
34703 static constexpr char const * const typestr{"SgExpression*"};
34704 static constexpr bool traverse{true};
34705 static constexpr auto mbr_ptr{&SgFinishExp::p_expression};
34706 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34707 using bind = Desc<SgFinishExp, SgExpression* SgFinishExp::*, &SgFinishExp::p_expression>;
34708};
34709template <> struct describe_field_t<SgFinishExp,SgStatement*,&SgFinishExp::p_body> {
34710 using parent = SgFinishExp;
34711 using field_type = SgStatement*;
34712 static constexpr size_t position{1};
34713 static constexpr char const * const name{"body"};
34714 static constexpr char const * const typestr{"SgStatement*"};
34715 static constexpr bool traverse{true};
34716 static constexpr auto mbr_ptr{&SgFinishExp::p_body};
34717 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34718 using bind = Desc<SgFinishExp, SgStatement* SgFinishExp::*, &SgFinishExp::p_body>;
34719};
34720template <> struct describe_node_t<SgFinishExp> {
34721 using node = SgFinishExp;
34722 using base = SgExpression;
34723 static constexpr char const * const name{"FinishExp"};
34724 static constexpr unsigned long variant{882};
34725 static constexpr bool concrete{true};
34726 using subclasses_t = mp::List<>;
34728};
34729template <> struct node_from_variant_t<882> { using type = SgFinishExp; };
34730
34731// Class: HereExp
34732template <> struct describe_field_t<SgHereExp,SgType*,&SgHereExp::p_expression_type> {
34733 using parent = SgHereExp;
34734 using field_type = SgType*;
34735 static constexpr size_t position{0};
34736 static constexpr char const * const name{"expression_type"};
34737 static constexpr char const * const typestr{"SgType*"};
34738 static constexpr bool traverse{false};
34739 static constexpr auto mbr_ptr{&SgHereExp::p_expression_type};
34740 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34741 using bind = Desc<SgHereExp, SgType* SgHereExp::*, &SgHereExp::p_expression_type>;
34742};
34743template <> struct describe_field_t<SgHereExp,SgExpression*,&SgHereExp::p_expression> {
34744 using parent = SgHereExp;
34745 using field_type = SgExpression*;
34746 static constexpr size_t position{1};
34747 static constexpr char const * const name{"expression"};
34748 static constexpr char const * const typestr{"SgExpression*"};
34749 static constexpr bool traverse{true};
34750 static constexpr auto mbr_ptr{&SgHereExp::p_expression};
34751 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34752 using bind = Desc<SgHereExp, SgExpression* SgHereExp::*, &SgHereExp::p_expression>;
34753};
34754template <> struct describe_node_t<SgHereExp> {
34755 using node = SgHereExp;
34756 using base = SgExpression;
34757 static constexpr char const * const name{"HereExp"};
34758 static constexpr unsigned long variant{883};
34759 static constexpr bool concrete{true};
34760 using subclasses_t = mp::List<>;
34762};
34763template <> struct node_from_variant_t<883> { using type = SgHereExp; };
34764
34765// Class: DotDotExp
34766template <> struct describe_node_t<SgDotDotExp> {
34767 using node = SgDotDotExp;
34768 using base = SgBinaryOp;
34769 static constexpr char const * const name{"DotDotExp"};
34770 static constexpr unsigned long variant{884};
34771 static constexpr bool concrete{true};
34772 using subclasses_t = mp::List<>;
34773 using fields_t = mp::List<>;
34774};
34775template <> struct node_from_variant_t<884> { using type = SgDotDotExp; };
34776
34777// Class: AsmNullInstruction
34779 using node = SgAsmNullInstruction;
34780 using base = SgAsmInstruction;
34781 static constexpr char const * const name{"AsmNullInstruction"};
34782 static constexpr unsigned long variant{885};
34783 static constexpr bool concrete{true};
34784 using subclasses_t = mp::List<>;
34785 using fields_t = mp::List<>;
34786};
34787template <> struct node_from_variant_t<885> { using type = SgAsmNullInstruction; };
34788
34789// Class: AdaComponentClause
34790template <> struct describe_field_t<SgAdaComponentClause,SgVarRefExp*,&SgAdaComponentClause::p_component> {
34792 using field_type = SgVarRefExp*;
34793 static constexpr size_t position{0};
34794 static constexpr char const * const name{"component"};
34795 static constexpr char const * const typestr{"SgVarRefExp*"};
34796 static constexpr bool traverse{true};
34797 static constexpr auto mbr_ptr{&SgAdaComponentClause::p_component};
34798 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34799 using bind = Desc<SgAdaComponentClause, SgVarRefExp* SgAdaComponentClause::*, &SgAdaComponentClause::p_component>;
34800};
34801template <> struct describe_field_t<SgAdaComponentClause,SgExpression*,&SgAdaComponentClause::p_offset> {
34803 using field_type = SgExpression*;
34804 static constexpr size_t position{1};
34805 static constexpr char const * const name{"offset"};
34806 static constexpr char const * const typestr{"SgExpression*"};
34807 static constexpr bool traverse{true};
34808 static constexpr auto mbr_ptr{&SgAdaComponentClause::p_offset};
34809 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34810 using bind = Desc<SgAdaComponentClause, SgExpression* SgAdaComponentClause::*, &SgAdaComponentClause::p_offset>;
34811};
34812template <> struct describe_field_t<SgAdaComponentClause,SgRangeExp*,&SgAdaComponentClause::p_range> {
34814 using field_type = SgRangeExp*;
34815 static constexpr size_t position{2};
34816 static constexpr char const * const name{"range"};
34817 static constexpr char const * const typestr{"SgRangeExp*"};
34818 static constexpr bool traverse{true};
34819 static constexpr auto mbr_ptr{&SgAdaComponentClause::p_range};
34820 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34821 using bind = Desc<SgAdaComponentClause, SgRangeExp* SgAdaComponentClause::*, &SgAdaComponentClause::p_range>;
34822};
34824 using node = SgAdaComponentClause;
34826 static constexpr char const * const name{"AdaComponentClause"};
34827 static constexpr unsigned long variant{886};
34828 static constexpr bool concrete{true};
34829 using subclasses_t = mp::List<>;
34831};
34832template <> struct node_from_variant_t<886> { using type = SgAdaComponentClause; };
34833
34834// Class: AdaIndexConstraint
34835template <> struct describe_field_t<SgAdaIndexConstraint,SgExpressionPtrList,&SgAdaIndexConstraint::p_indexRanges> {
34837 using field_type = SgExpressionPtrList;
34838 static constexpr size_t position{0};
34839 static constexpr char const * const name{"indexRanges"};
34840 static constexpr char const * const typestr{"SgExpressionPtrList"};
34841 static constexpr bool traverse{true};
34842 static constexpr auto mbr_ptr{&SgAdaIndexConstraint::p_indexRanges};
34843 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34844 using bind = Desc<SgAdaIndexConstraint, SgExpressionPtrList SgAdaIndexConstraint::*, &SgAdaIndexConstraint::p_indexRanges>;
34845};
34847 using node = SgAdaIndexConstraint;
34848 using base = SgAdaTypeConstraint;
34849 static constexpr char const * const name{"AdaIndexConstraint"};
34850 static constexpr unsigned long variant{887};
34851 static constexpr bool concrete{true};
34852 using subclasses_t = mp::List<>;
34854};
34855template <> struct node_from_variant_t<887> { using type = SgAdaIndexConstraint; };
34856
34857// Class: AdaModularType
34858template <> struct describe_field_t<SgAdaModularType,SgExpression*,&SgAdaModularType::p_modexpr> {
34859 using parent = SgAdaModularType;
34860 using field_type = SgExpression*;
34861 static constexpr size_t position{0};
34862 static constexpr char const * const name{"modexpr"};
34863 static constexpr char const * const typestr{"SgExpression*"};
34864 static constexpr bool traverse{true};
34865 static constexpr auto mbr_ptr{&SgAdaModularType::p_modexpr};
34866 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34867 using bind = Desc<SgAdaModularType, SgExpression* SgAdaModularType::*, &SgAdaModularType::p_modexpr>;
34868};
34870 using node = SgAdaModularType;
34871 using base = SgType;
34872 static constexpr char const * const name{"AdaModularType"};
34873 static constexpr unsigned long variant{888};
34874 static constexpr bool concrete{true};
34875 using subclasses_t = mp::List<>;
34877};
34878template <> struct node_from_variant_t<888> { using type = SgAdaModularType; };
34879
34880// Class: AdaRepresentationClause
34881template <> struct describe_field_t<SgAdaRepresentationClause,SgType*,&SgAdaRepresentationClause::p_recordType> {
34883 using field_type = SgType*;
34884 static constexpr size_t position{0};
34885 static constexpr char const * const name{"recordType"};
34886 static constexpr char const * const typestr{"SgType*"};
34887 static constexpr bool traverse{false};
34888 static constexpr auto mbr_ptr{&SgAdaRepresentationClause::p_recordType};
34889 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34890 using bind = Desc<SgAdaRepresentationClause, SgType* SgAdaRepresentationClause::*, &SgAdaRepresentationClause::p_recordType>;
34891};
34892template <> struct describe_field_t<SgAdaRepresentationClause,SgExpression*,&SgAdaRepresentationClause::p_alignment> {
34894 using field_type = SgExpression*;
34895 static constexpr size_t position{1};
34896 static constexpr char const * const name{"alignment"};
34897 static constexpr char const * const typestr{"SgExpression*"};
34898 static constexpr bool traverse{true};
34899 static constexpr auto mbr_ptr{&SgAdaRepresentationClause::p_alignment};
34900 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34901 using bind = Desc<SgAdaRepresentationClause, SgExpression* SgAdaRepresentationClause::*, &SgAdaRepresentationClause::p_alignment>;
34902};
34903template <> struct describe_field_t<SgAdaRepresentationClause,SgBasicBlock*,&SgAdaRepresentationClause::p_components> {
34905 using field_type = SgBasicBlock*;
34906 static constexpr size_t position{2};
34907 static constexpr char const * const name{"components"};
34908 static constexpr char const * const typestr{"SgBasicBlock*"};
34909 static constexpr bool traverse{true};
34910 static constexpr auto mbr_ptr{&SgAdaRepresentationClause::p_components};
34911 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34912 using bind = Desc<SgAdaRepresentationClause, SgBasicBlock* SgAdaRepresentationClause::*, &SgAdaRepresentationClause::p_components>;
34913};
34923template <> struct node_from_variant_t<889> { using type = SgAdaRepresentationClause; };
34924
34925// Class: AdaFunctionRenamingDecl
34926template <> struct describe_field_t<SgAdaFunctionRenamingDecl,SgExpression*,&SgAdaFunctionRenamingDecl::p_renamed_function> {
34928 using field_type = SgExpression*;
34929 static constexpr size_t position{0};
34930 static constexpr char const * const name{"renamed_function"};
34931 static constexpr char const * const typestr{"SgExpression*"};
34932 static constexpr bool traverse{true};
34933 static constexpr auto mbr_ptr{&SgAdaFunctionRenamingDecl::p_renamed_function};
34934 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34935 using bind = Desc<SgAdaFunctionRenamingDecl, SgExpression* SgAdaFunctionRenamingDecl::*, &SgAdaFunctionRenamingDecl::p_renamed_function>;
34936};
34940 static constexpr char const * const name{"AdaFunctionRenamingDecl"};
34941 static constexpr unsigned long variant{890};
34942 static constexpr bool concrete{true};
34943 using subclasses_t = mp::List<>;
34945};
34946template <> struct node_from_variant_t<890> { using type = SgAdaFunctionRenamingDecl; };
34947
34948// Class: AdaSelectStmt
34949template <> struct describe_field_t<SgAdaSelectStmt,SgAdaSelectAlternativeStmt*,&SgAdaSelectStmt::p_select_path> {
34950 using parent = SgAdaSelectStmt;
34952 static constexpr size_t position{0};
34953 static constexpr char const * const name{"select_path"};
34954 static constexpr char const * const typestr{"SgAdaSelectAlternativeStmt*"};
34955 static constexpr bool traverse{true};
34956 static constexpr auto mbr_ptr{&SgAdaSelectStmt::p_select_path};
34957 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34958 using bind = Desc<SgAdaSelectStmt, SgAdaSelectAlternativeStmt* SgAdaSelectStmt::*, &SgAdaSelectStmt::p_select_path>;
34959};
34960template <> struct describe_field_t<SgAdaSelectStmt,SgAdaSelectAlternativeStmt*,&SgAdaSelectStmt::p_or_path> {
34961 using parent = SgAdaSelectStmt;
34963 static constexpr size_t position{1};
34964 static constexpr char const * const name{"or_path"};
34965 static constexpr char const * const typestr{"SgAdaSelectAlternativeStmt*"};
34966 static constexpr bool traverse{true};
34967 static constexpr auto mbr_ptr{&SgAdaSelectStmt::p_or_path};
34968 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34969 using bind = Desc<SgAdaSelectStmt, SgAdaSelectAlternativeStmt* SgAdaSelectStmt::*, &SgAdaSelectStmt::p_or_path>;
34970};
34971template <> struct describe_field_t<SgAdaSelectStmt,SgBasicBlock*,&SgAdaSelectStmt::p_else_path> {
34972 using parent = SgAdaSelectStmt;
34973 using field_type = SgBasicBlock*;
34974 static constexpr size_t position{2};
34975 static constexpr char const * const name{"else_path"};
34976 static constexpr char const * const typestr{"SgBasicBlock*"};
34977 static constexpr bool traverse{true};
34978 static constexpr auto mbr_ptr{&SgAdaSelectStmt::p_else_path};
34979 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34980 using bind = Desc<SgAdaSelectStmt, SgBasicBlock* SgAdaSelectStmt::*, &SgAdaSelectStmt::p_else_path>;
34981};
34982template <> struct describe_field_t<SgAdaSelectStmt,SgBasicBlock*,&SgAdaSelectStmt::p_abort_path> {
34983 using parent = SgAdaSelectStmt;
34984 using field_type = SgBasicBlock*;
34985 static constexpr size_t position{3};
34986 static constexpr char const * const name{"abort_path"};
34987 static constexpr char const * const typestr{"SgBasicBlock*"};
34988 static constexpr bool traverse{true};
34989 static constexpr auto mbr_ptr{&SgAdaSelectStmt::p_abort_path};
34990 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
34991 using bind = Desc<SgAdaSelectStmt, SgBasicBlock* SgAdaSelectStmt::*, &SgAdaSelectStmt::p_abort_path>;
34992};
34993template <> struct describe_field_t<SgAdaSelectStmt,SgAdaSelectStmt::select_type_enum,&SgAdaSelectStmt::p_select_type> {
34994 using parent = SgAdaSelectStmt;
34995 using field_type = SgAdaSelectStmt::select_type_enum;
34996 static constexpr size_t position{4};
34997 static constexpr char const * const name{"select_type"};
34998 static constexpr char const * const typestr{"SgAdaSelectStmt::select_type_enum"};
34999 static constexpr bool traverse{false};
35000 static constexpr auto mbr_ptr{&SgAdaSelectStmt::p_select_type};
35001 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35002 using bind = Desc<SgAdaSelectStmt, SgAdaSelectStmt::select_type_enum SgAdaSelectStmt::*, &SgAdaSelectStmt::p_select_type>;
35003};
35013template <> struct node_from_variant_t<891> { using type = SgAdaSelectStmt; };
35014
35015// Class: AdaSelectAlternativeStmt
35016template <> struct describe_field_t<SgAdaSelectAlternativeStmt,SgBasicBlock*,&SgAdaSelectAlternativeStmt::p_body> {
35018 using field_type = SgBasicBlock*;
35019 static constexpr size_t position{0};
35020 static constexpr char const * const name{"body"};
35021 static constexpr char const * const typestr{"SgBasicBlock*"};
35022 static constexpr bool traverse{true};
35023 static constexpr auto mbr_ptr{&SgAdaSelectAlternativeStmt::p_body};
35024 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35025 using bind = Desc<SgAdaSelectAlternativeStmt, SgBasicBlock* SgAdaSelectAlternativeStmt::*, &SgAdaSelectAlternativeStmt::p_body>;
35026};
35027template <> struct describe_field_t<SgAdaSelectAlternativeStmt,SgExpression*,&SgAdaSelectAlternativeStmt::p_guard> {
35029 using field_type = SgExpression*;
35030 static constexpr size_t position{1};
35031 static constexpr char const * const name{"guard"};
35032 static constexpr char const * const typestr{"SgExpression*"};
35033 static constexpr bool traverse{true};
35034 static constexpr auto mbr_ptr{&SgAdaSelectAlternativeStmt::p_guard};
35035 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35036 using bind = Desc<SgAdaSelectAlternativeStmt, SgExpression* SgAdaSelectAlternativeStmt::*, &SgAdaSelectAlternativeStmt::p_guard>;
35037};
35038template <> struct describe_field_t<SgAdaSelectAlternativeStmt,SgAdaSelectAlternativeStmt*,&SgAdaSelectAlternativeStmt::p_next> {
35041 static constexpr size_t position{2};
35042 static constexpr char const * const name{"next"};
35043 static constexpr char const * const typestr{"SgAdaSelectAlternativeStmt*"};
35044 static constexpr bool traverse{true};
35045 static constexpr auto mbr_ptr{&SgAdaSelectAlternativeStmt::p_next};
35046 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35047 using bind = Desc<SgAdaSelectAlternativeStmt, SgAdaSelectAlternativeStmt* SgAdaSelectAlternativeStmt::*, &SgAdaSelectAlternativeStmt::p_next>;
35048};
35058template <> struct node_from_variant_t<892> { using type = SgAdaSelectAlternativeStmt; };
35059
35060// Class: AdaTerminateStmt
35062 using node = SgAdaTerminateStmt;
35063 using base = SgStatement;
35064 static constexpr char const * const name{"AdaTerminateStmt"};
35065 static constexpr unsigned long variant{893};
35066 static constexpr bool concrete{true};
35067 using subclasses_t = mp::List<>;
35068 using fields_t = mp::List<>;
35069};
35070template <> struct node_from_variant_t<893> { using type = SgAdaTerminateStmt; };
35071
35072// Class: AsmAarch32Coprocessor
35075 using base = SgAsmExpression;
35076 static constexpr char const * const name{"AsmAarch32Coprocessor"};
35077 static constexpr unsigned long variant{895};
35078 static constexpr bool concrete{true};
35079 using subclasses_t = mp::List<>;
35080 using fields_t = mp::List<>;
35081};
35082template <> struct node_from_variant_t<895> { using type = SgAsmAarch32Coprocessor; };
35083
35084// Class: AdaAttributeClause
35085template <> struct describe_field_t<SgAdaAttributeClause,SgAdaAttributeExp*,&SgAdaAttributeClause::p_attribute> {
35088 static constexpr size_t position{0};
35089 static constexpr char const * const name{"attribute"};
35090 static constexpr char const * const typestr{"SgAdaAttributeExp*"};
35091 static constexpr bool traverse{true};
35092 static constexpr auto mbr_ptr{&SgAdaAttributeClause::p_attribute};
35093 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35094 using bind = Desc<SgAdaAttributeClause, SgAdaAttributeExp* SgAdaAttributeClause::*, &SgAdaAttributeClause::p_attribute>;
35095};
35096template <> struct describe_field_t<SgAdaAttributeClause,SgExpression*,&SgAdaAttributeClause::p_size> {
35098 using field_type = SgExpression*;
35099 static constexpr size_t position{1};
35100 static constexpr char const * const name{"size"};
35101 static constexpr char const * const typestr{"SgExpression*"};
35102 static constexpr bool traverse{true};
35103 static constexpr auto mbr_ptr{&SgAdaAttributeClause::p_size};
35104 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35105 using bind = Desc<SgAdaAttributeClause, SgExpression* SgAdaAttributeClause::*, &SgAdaAttributeClause::p_size>;
35106};
35108 using node = SgAdaAttributeClause;
35110 static constexpr char const * const name{"AdaAttributeClause"};
35111 static constexpr unsigned long variant{896};
35112 static constexpr bool concrete{true};
35113 using subclasses_t = mp::List<>;
35115};
35116template <> struct node_from_variant_t<896> { using type = SgAdaAttributeClause; };
35117
35118// Class: AsmBinaryConcat
35120 using node = SgAsmBinaryConcat;
35122 static constexpr char const * const name{"AsmBinaryConcat"};
35123 static constexpr unsigned long variant{897};
35124 static constexpr bool concrete{true};
35125 using subclasses_t = mp::List<>;
35126 using fields_t = mp::List<>;
35127};
35128template <> struct node_from_variant_t<897> { using type = SgAsmBinaryConcat; };
35129
35130// Class: AsmByteOrder
35131template <> struct describe_node_t<SgAsmByteOrder> {
35132 using node = SgAsmByteOrder;
35133 using base = SgAsmExpression;
35134 static constexpr char const * const name{"AsmByteOrder"};
35135 static constexpr unsigned long variant{898};
35136 static constexpr bool concrete{true};
35137 using subclasses_t = mp::List<>;
35138 using fields_t = mp::List<>;
35139};
35140template <> struct node_from_variant_t<898> { using type = SgAsmByteOrder; };
35141
35142// Class: AdaDerivedType
35143template <> struct describe_field_t<SgAdaDerivedType,SgType*,&SgAdaDerivedType::p_base_type> {
35144 using parent = SgAdaDerivedType;
35145 using field_type = SgType*;
35146 static constexpr size_t position{0};
35147 static constexpr char const * const name{"base_type"};
35148 static constexpr char const * const typestr{"SgType*"};
35149 static constexpr bool traverse{true};
35150 static constexpr auto mbr_ptr{&SgAdaDerivedType::p_base_type};
35151 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35152 using bind = Desc<SgAdaDerivedType, SgType* SgAdaDerivedType::*, &SgAdaDerivedType::p_base_type>;
35153};
35155 using node = SgAdaDerivedType;
35156 using base = SgType;
35157 static constexpr char const * const name{"AdaDerivedType"};
35158 static constexpr unsigned long variant{899};
35159 static constexpr bool concrete{true};
35160 using subclasses_t = mp::List<>;
35162};
35163template <> struct node_from_variant_t<899> { using type = SgAdaDerivedType; };
35164
35165// Class: AdaAttributeExp
35166template <> struct describe_field_t<SgAdaAttributeExp,SgName,&SgAdaAttributeExp::p_attribute> {
35167 using parent = SgAdaAttributeExp;
35168 using field_type = SgName;
35169 static constexpr size_t position{0};
35170 static constexpr char const * const name{"attribute"};
35171 static constexpr char const * const typestr{"SgName"};
35172 static constexpr bool traverse{false};
35173 static constexpr auto mbr_ptr{&SgAdaAttributeExp::p_attribute};
35174 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35175 using bind = Desc<SgAdaAttributeExp, SgName SgAdaAttributeExp::*, &SgAdaAttributeExp::p_attribute>;
35176};
35177template <> struct describe_field_t<SgAdaAttributeExp,SgExpression*,&SgAdaAttributeExp::p_object> {
35178 using parent = SgAdaAttributeExp;
35179 using field_type = SgExpression*;
35180 static constexpr size_t position{1};
35181 static constexpr char const * const name{"object"};
35182 static constexpr char const * const typestr{"SgExpression*"};
35183 static constexpr bool traverse{true};
35184 static constexpr auto mbr_ptr{&SgAdaAttributeExp::p_object};
35185 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35186 using bind = Desc<SgAdaAttributeExp, SgExpression* SgAdaAttributeExp::*, &SgAdaAttributeExp::p_object>;
35187};
35188template <> struct describe_field_t<SgAdaAttributeExp,SgExprListExp*,&SgAdaAttributeExp::p_args> {
35189 using parent = SgAdaAttributeExp;
35190 using field_type = SgExprListExp*;
35191 static constexpr size_t position{2};
35192 static constexpr char const * const name{"args"};
35193 static constexpr char const * const typestr{"SgExprListExp*"};
35194 static constexpr bool traverse{true};
35195 static constexpr auto mbr_ptr{&SgAdaAttributeExp::p_args};
35196 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35197 using bind = Desc<SgAdaAttributeExp, SgExprListExp* SgAdaAttributeExp::*, &SgAdaAttributeExp::p_args>;
35198};
35199template <> struct describe_field_t<SgAdaAttributeExp,SgType*,&SgAdaAttributeExp::p_attrType> {
35200 using parent = SgAdaAttributeExp;
35201 using field_type = SgType*;
35202 static constexpr size_t position{3};
35203 static constexpr char const * const name{"attrType"};
35204 static constexpr char const * const typestr{"SgType*"};
35205 static constexpr bool traverse{false};
35206 static constexpr auto mbr_ptr{&SgAdaAttributeExp::p_attrType};
35207 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35208 using bind = Desc<SgAdaAttributeExp, SgType* SgAdaAttributeExp::*, &SgAdaAttributeExp::p_attrType>;
35209};
35219template <> struct node_from_variant_t<900> { using type = SgAdaAttributeExp; };
35220
35221// Class: AdaEnumRepresentationClause
35222template <> struct describe_field_t<SgAdaEnumRepresentationClause,SgType*,&SgAdaEnumRepresentationClause::p_enumType> {
35224 using field_type = SgType*;
35225 static constexpr size_t position{0};
35226 static constexpr char const * const name{"enumType"};
35227 static constexpr char const * const typestr{"SgType*"};
35228 static constexpr bool traverse{false};
35229 static constexpr auto mbr_ptr{&SgAdaEnumRepresentationClause::p_enumType};
35230 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35231 using bind = Desc<SgAdaEnumRepresentationClause, SgType* SgAdaEnumRepresentationClause::*, &SgAdaEnumRepresentationClause::p_enumType>;
35232};
35233template <> struct describe_field_t<SgAdaEnumRepresentationClause,SgExprListExp*,&SgAdaEnumRepresentationClause::p_components> {
35235 using field_type = SgExprListExp*;
35236 static constexpr size_t position{1};
35237 static constexpr char const * const name{"components"};
35238 static constexpr char const * const typestr{"SgExprListExp*"};
35239 static constexpr bool traverse{true};
35240 static constexpr auto mbr_ptr{&SgAdaEnumRepresentationClause::p_components};
35241 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35242 using bind = Desc<SgAdaEnumRepresentationClause, SgExprListExp* SgAdaEnumRepresentationClause::*, &SgAdaEnumRepresentationClause::p_components>;
35243};
35247 static constexpr char const * const name{"AdaEnumRepresentationClause"};
35248 static constexpr unsigned long variant{901};
35249 static constexpr bool concrete{true};
35250 using subclasses_t = mp::List<>;
35252};
35253template <> struct node_from_variant_t<901> { using type = SgAdaEnumRepresentationClause; };
35254
35255// Class: AsmBinaryPreupdate
35257 using node = SgAsmBinaryPreupdate;
35259 static constexpr char const * const name{"AsmBinaryPreupdate"};
35260 static constexpr unsigned long variant{902};
35261 static constexpr bool concrete{true};
35262 using subclasses_t = mp::List<>;
35263 using fields_t = mp::List<>;
35264};
35265template <> struct node_from_variant_t<902> { using type = SgAsmBinaryPreupdate; };
35266
35267// Class: AsmBinaryPostupdate
35271 static constexpr char const * const name{"AsmBinaryPostupdate"};
35272 static constexpr unsigned long variant{903};
35273 static constexpr bool concrete{true};
35274 using subclasses_t = mp::List<>;
35275 using fields_t = mp::List<>;
35276};
35277template <> struct node_from_variant_t<903> { using type = SgAsmBinaryPostupdate; };
35278
35279// Class: AdaOthersExp
35280template <> struct describe_node_t<SgAdaOthersExp> {
35281 using node = SgAdaOthersExp;
35282 using base = SgExpression;
35283 static constexpr char const * const name{"AdaOthersExp"};
35284 static constexpr unsigned long variant{904};
35285 static constexpr bool concrete{true};
35286 using subclasses_t = mp::List<>;
35287 using fields_t = mp::List<>;
35288};
35289template <> struct node_from_variant_t<904> { using type = SgAdaOthersExp; };
35290
35291// Class: AdaRenamingSymbol
35292template <> struct describe_field_t<SgAdaRenamingSymbol,SgAdaRenamingDecl*,&SgAdaRenamingSymbol::p_declaration> {
35295 static constexpr size_t position{0};
35296 static constexpr char const * const name{"declaration"};
35297 static constexpr char const * const typestr{"SgAdaRenamingDecl*"};
35298 static constexpr bool traverse{true};
35299 static constexpr auto mbr_ptr{&SgAdaRenamingSymbol::p_declaration};
35300 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35301 using bind = Desc<SgAdaRenamingSymbol, SgAdaRenamingDecl* SgAdaRenamingSymbol::*, &SgAdaRenamingSymbol::p_declaration>;
35302};
35304 using node = SgAdaRenamingSymbol;
35305 using base = SgSymbol;
35306 static constexpr char const * const name{"AdaRenamingSymbol"};
35307 static constexpr unsigned long variant{905};
35308 static constexpr bool concrete{true};
35309 using subclasses_t = mp::List<>;
35311};
35312template <> struct node_from_variant_t<905> { using type = SgAdaRenamingSymbol; };
35313
35314// Class: AdaRenamingRefExp
35315template <> struct describe_field_t<SgAdaRenamingRefExp,SgAdaRenamingSymbol*,&SgAdaRenamingRefExp::p_symbol> {
35318 static constexpr size_t position{0};
35319 static constexpr char const * const name{"symbol"};
35320 static constexpr char const * const typestr{"SgAdaRenamingSymbol*"};
35321 static constexpr bool traverse{false};
35322 static constexpr auto mbr_ptr{&SgAdaRenamingRefExp::p_symbol};
35323 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35324 using bind = Desc<SgAdaRenamingRefExp, SgAdaRenamingSymbol* SgAdaRenamingRefExp::*, &SgAdaRenamingRefExp::p_symbol>;
35325};
35327 using node = SgAdaRenamingRefExp;
35328 using base = SgExpression;
35329 static constexpr char const * const name{"AdaRenamingRefExp"};
35330 static constexpr unsigned long variant{906};
35331 static constexpr bool concrete{true};
35332 using subclasses_t = mp::List<>;
35334};
35335template <> struct node_from_variant_t<906> { using type = SgAdaRenamingRefExp; };
35336
35337// Class: AdaGenericDecl
35338template <> struct describe_field_t<SgAdaGenericDecl,SgName,&SgAdaGenericDecl::p_name> {
35339 using parent = SgAdaGenericDecl;
35340 using field_type = SgName;
35341 static constexpr size_t position{0};
35342 static constexpr char const * const name{"name"};
35343 static constexpr char const * const typestr{"SgName"};
35344 static constexpr bool traverse{false};
35345 static constexpr auto mbr_ptr{&SgAdaGenericDecl::p_name};
35346 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35347 using bind = Desc<SgAdaGenericDecl, SgName SgAdaGenericDecl::*, &SgAdaGenericDecl::p_name>;
35348};
35349template <> struct describe_field_t<SgAdaGenericDecl,SgAdaGenericDefn*,&SgAdaGenericDecl::p_definition> {
35350 using parent = SgAdaGenericDecl;
35352 static constexpr size_t position{1};
35353 static constexpr char const * const name{"definition"};
35354 static constexpr char const * const typestr{"SgAdaGenericDefn*"};
35355 static constexpr bool traverse{true};
35356 static constexpr auto mbr_ptr{&SgAdaGenericDecl::p_definition};
35357 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35358 using bind = Desc<SgAdaGenericDecl, SgAdaGenericDefn* SgAdaGenericDecl::*, &SgAdaGenericDecl::p_definition>;
35359};
35360template <> struct describe_field_t<SgAdaGenericDecl,SgDeclarationStatement*,&SgAdaGenericDecl::p_declaration> {
35361 using parent = SgAdaGenericDecl;
35363 static constexpr size_t position{2};
35364 static constexpr char const * const name{"declaration"};
35365 static constexpr char const * const typestr{"SgDeclarationStatement*"};
35366 static constexpr bool traverse{true};
35367 static constexpr auto mbr_ptr{&SgAdaGenericDecl::p_declaration};
35368 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35369 using bind = Desc<SgAdaGenericDecl, SgDeclarationStatement* SgAdaGenericDecl::*, &SgAdaGenericDecl::p_declaration>;
35370};
35371template <> struct describe_field_t<SgAdaGenericDecl,SgScopeStatement*,&SgAdaGenericDecl::p_scope> {
35372 using parent = SgAdaGenericDecl;
35374 static constexpr size_t position{3};
35375 static constexpr char const * const name{"scope"};
35376 static constexpr char const * const typestr{"SgScopeStatement*"};
35377 static constexpr bool traverse{false};
35378 static constexpr auto mbr_ptr{&SgAdaGenericDecl::p_scope};
35379 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35380 using bind = Desc<SgAdaGenericDecl, SgScopeStatement* SgAdaGenericDecl::*, &SgAdaGenericDecl::p_scope>;
35381};
35391template <> struct node_from_variant_t<907> { using type = SgAdaGenericDecl; };
35392
35393// Class: AdaGenericDefn
35394template <> struct describe_field_t<SgAdaGenericDefn,SgDeclarationStatementPtrList,&SgAdaGenericDefn::p_declarations> {
35395 using parent = SgAdaGenericDefn;
35396 using field_type = SgDeclarationStatementPtrList;
35397 static constexpr size_t position{0};
35398 static constexpr char const * const name{"declarations"};
35399 static constexpr char const * const typestr{"SgDeclarationStatementPtrList"};
35400 static constexpr bool traverse{true};
35401 static constexpr auto mbr_ptr{&SgAdaGenericDefn::p_declarations};
35402 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35403 using bind = Desc<SgAdaGenericDefn, SgDeclarationStatementPtrList SgAdaGenericDefn::*, &SgAdaGenericDefn::p_declarations>;
35404};
35406 using node = SgAdaGenericDefn;
35407 using base = SgScopeStatement;
35408 static constexpr char const * const name{"AdaGenericDefn"};
35409 static constexpr unsigned long variant{908};
35410 static constexpr bool concrete{true};
35411 using subclasses_t = mp::List<>;
35413};
35414template <> struct node_from_variant_t<908> { using type = SgAdaGenericDefn; };
35415
35416// Class: AdaFormalType
35417template <> struct describe_field_t<SgAdaFormalType,bool,&SgAdaFormalType::p_is_private> {
35418 using parent = SgAdaFormalType;
35419 using field_type = bool;
35420 static constexpr size_t position{0};
35421 static constexpr char const * const name{"is_private"};
35422 static constexpr char const * const typestr{"bool"};
35423 static constexpr bool traverse{false};
35424 static constexpr auto mbr_ptr{&SgAdaFormalType::p_is_private};
35425 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35426 using bind = Desc<SgAdaFormalType, bool SgAdaFormalType::*, &SgAdaFormalType::p_is_private>;
35427};
35428template <> struct describe_field_t<SgAdaFormalType,SgType*,&SgAdaFormalType::p_formal_type> {
35429 using parent = SgAdaFormalType;
35430 using field_type = SgType*;
35431 static constexpr size_t position{1};
35432 static constexpr char const * const name{"formal_type"};
35433 static constexpr char const * const typestr{"SgType*"};
35434 static constexpr bool traverse{false};
35435 static constexpr auto mbr_ptr{&SgAdaFormalType::p_formal_type};
35436 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35437 using bind = Desc<SgAdaFormalType, SgType* SgAdaFormalType::*, &SgAdaFormalType::p_formal_type>;
35438};
35440 using node = SgAdaFormalType;
35441 using base = SgNamedType;
35442 static constexpr char const * const name{"AdaFormalType"};
35443 static constexpr unsigned long variant{909};
35444 static constexpr bool concrete{true};
35445 using subclasses_t = mp::List<>;
35447};
35448template <> struct node_from_variant_t<909> { using type = SgAdaFormalType; };
35449
35450// Class: AdaGenericSymbol
35451template <> struct describe_field_t<SgAdaGenericSymbol,SgDeclarationStatement*,&SgAdaGenericSymbol::p_declaration> {
35452 using parent = SgAdaGenericSymbol;
35454 static constexpr size_t position{0};
35455 static constexpr char const * const name{"declaration"};
35456 static constexpr char const * const typestr{"SgDeclarationStatement*"};
35457 static constexpr bool traverse{true};
35458 static constexpr auto mbr_ptr{&SgAdaGenericSymbol::p_declaration};
35459 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35460 using bind = Desc<SgAdaGenericSymbol, SgDeclarationStatement* SgAdaGenericSymbol::*, &SgAdaGenericSymbol::p_declaration>;
35461};
35463 using node = SgAdaGenericSymbol;
35464 using base = SgSymbol;
35465 static constexpr char const * const name{"AdaGenericSymbol"};
35466 static constexpr unsigned long variant{910};
35467 static constexpr bool concrete{true};
35468 using subclasses_t = mp::List<>;
35470};
35471template <> struct node_from_variant_t<910> { using type = SgAdaGenericSymbol; };
35472
35473// Class: AdaFormalTypeDecl
35474template <> struct describe_field_t<SgAdaFormalTypeDecl,SgName,&SgAdaFormalTypeDecl::p_name> {
35476 using field_type = SgName;
35477 static constexpr size_t position{0};
35478 static constexpr char const * const name{"name"};
35479 static constexpr char const * const typestr{"SgName"};
35480 static constexpr bool traverse{false};
35481 static constexpr auto mbr_ptr{&SgAdaFormalTypeDecl::p_name};
35482 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35483 using bind = Desc<SgAdaFormalTypeDecl, SgName SgAdaFormalTypeDecl::*, &SgAdaFormalTypeDecl::p_name>;
35484};
35485template <> struct describe_field_t<SgAdaFormalTypeDecl,SgAdaFormalType*,&SgAdaFormalTypeDecl::p_type> {
35487 using field_type = SgAdaFormalType*;
35488 static constexpr size_t position{1};
35489 static constexpr char const * const name{"type"};
35490 static constexpr char const * const typestr{"SgAdaFormalType*"};
35491 static constexpr bool traverse{false};
35492 static constexpr auto mbr_ptr{&SgAdaFormalTypeDecl::p_type};
35493 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35494 using bind = Desc<SgAdaFormalTypeDecl, SgAdaFormalType* SgAdaFormalTypeDecl::*, &SgAdaFormalTypeDecl::p_type>;
35495};
35496template <> struct describe_field_t<SgAdaFormalTypeDecl,SgAdaParameterList*,&SgAdaFormalTypeDecl::p_discriminants> {
35499 static constexpr size_t position{2};
35500 static constexpr char const * const name{"discriminants"};
35501 static constexpr char const * const typestr{"SgAdaParameterList*"};
35502 static constexpr bool traverse{true};
35503 static constexpr auto mbr_ptr{&SgAdaFormalTypeDecl::p_discriminants};
35504 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35505 using bind = Desc<SgAdaFormalTypeDecl, SgAdaParameterList* SgAdaFormalTypeDecl::*, &SgAdaFormalTypeDecl::p_discriminants>;
35506};
35508 using node = SgAdaFormalTypeDecl;
35510 static constexpr char const * const name{"AdaFormalTypeDecl"};
35511 static constexpr unsigned long variant{911};
35512 static constexpr bool concrete{true};
35513 using subclasses_t = mp::List<>;
35515};
35516template <> struct node_from_variant_t<911> { using type = SgAdaFormalTypeDecl; };
35517
35518// Class: AdaUnitRefExp
35519template <> struct describe_field_t<SgAdaUnitRefExp,SgSymbol*,&SgAdaUnitRefExp::p_symbol> {
35520 using parent = SgAdaUnitRefExp;
35521 using field_type = SgSymbol*;
35522 static constexpr size_t position{0};
35523 static constexpr char const * const name{"symbol"};
35524 static constexpr char const * const typestr{"SgSymbol*"};
35525 static constexpr bool traverse{false};
35526 static constexpr auto mbr_ptr{&SgAdaUnitRefExp::p_symbol};
35527 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35528 using bind = Desc<SgAdaUnitRefExp, SgSymbol* SgAdaUnitRefExp::*, &SgAdaUnitRefExp::p_symbol>;
35529};
35531 using node = SgAdaUnitRefExp;
35532 using base = SgExpression;
35533 static constexpr char const * const name{"AdaUnitRefExp"};
35534 static constexpr unsigned long variant{912};
35535 static constexpr bool concrete{true};
35536 using subclasses_t = mp::List<>;
35538};
35539template <> struct node_from_variant_t<912> { using type = SgAdaUnitRefExp; };
35540
35541// Class: AdaDiscriminatedTypeDecl
35542template <> struct describe_field_t<SgAdaDiscriminatedTypeDecl,SgDeclarationScope*,&SgAdaDiscriminatedTypeDecl::p_discriminantScope> {
35545 static constexpr size_t position{0};
35546 static constexpr char const * const name{"discriminantScope"};
35547 static constexpr char const * const typestr{"SgDeclarationScope*"};
35548 static constexpr bool traverse{false};
35549 static constexpr auto mbr_ptr{&SgAdaDiscriminatedTypeDecl::p_discriminantScope};
35550 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35551 using bind = Desc<SgAdaDiscriminatedTypeDecl, SgDeclarationScope* SgAdaDiscriminatedTypeDecl::*, &SgAdaDiscriminatedTypeDecl::p_discriminantScope>;
35552};
35553template <> struct describe_field_t<SgAdaDiscriminatedTypeDecl,SgAdaParameterList*,&SgAdaDiscriminatedTypeDecl::p_discriminants> {
35556 static constexpr size_t position{1};
35557 static constexpr char const * const name{"discriminants"};
35558 static constexpr char const * const typestr{"SgAdaParameterList*"};
35559 static constexpr bool traverse{true};
35560 static constexpr auto mbr_ptr{&SgAdaDiscriminatedTypeDecl::p_discriminants};
35561 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35562 using bind = Desc<SgAdaDiscriminatedTypeDecl, SgAdaParameterList* SgAdaDiscriminatedTypeDecl::*, &SgAdaDiscriminatedTypeDecl::p_discriminants>;
35563};
35564template <> struct describe_field_t<SgAdaDiscriminatedTypeDecl,SgDeclarationStatement*,&SgAdaDiscriminatedTypeDecl::p_discriminatedDecl> {
35567 static constexpr size_t position{2};
35568 static constexpr char const * const name{"discriminatedDecl"};
35569 static constexpr char const * const typestr{"SgDeclarationStatement*"};
35570 static constexpr bool traverse{true};
35571 static constexpr auto mbr_ptr{&SgAdaDiscriminatedTypeDecl::p_discriminatedDecl};
35572 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35573 using bind = Desc<SgAdaDiscriminatedTypeDecl, SgDeclarationStatement* SgAdaDiscriminatedTypeDecl::*, &SgAdaDiscriminatedTypeDecl::p_discriminatedDecl>;
35574};
35575template <> struct describe_field_t<SgAdaDiscriminatedTypeDecl,SgAdaDiscriminatedType*,&SgAdaDiscriminatedTypeDecl::p_type> {
35578 static constexpr size_t position{3};
35579 static constexpr char const * const name{"type"};
35580 static constexpr char const * const typestr{"SgAdaDiscriminatedType*"};
35581 static constexpr bool traverse{false};
35582 static constexpr auto mbr_ptr{&SgAdaDiscriminatedTypeDecl::p_type};
35583 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35584 using bind = Desc<SgAdaDiscriminatedTypeDecl, SgAdaDiscriminatedType* SgAdaDiscriminatedTypeDecl::*, &SgAdaDiscriminatedTypeDecl::p_type>;
35585};
35586template <> struct describe_field_t<SgAdaDiscriminatedTypeDecl,SgScopeStatement*,&SgAdaDiscriminatedTypeDecl::p_scope> {
35589 static constexpr size_t position{4};
35590 static constexpr char const * const name{"scope"};
35591 static constexpr char const * const typestr{"SgScopeStatement*"};
35592 static constexpr bool traverse{false};
35593 static constexpr auto mbr_ptr{&SgAdaDiscriminatedTypeDecl::p_scope};
35594 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35595 using bind = Desc<SgAdaDiscriminatedTypeDecl, SgScopeStatement* SgAdaDiscriminatedTypeDecl::*, &SgAdaDiscriminatedTypeDecl::p_scope>;
35596};
35606template <> struct node_from_variant_t<913> { using type = SgAdaDiscriminatedTypeDecl; };
35607
35608// Class: AdaDiscriminatedType
35611 using base = SgNamedType;
35612 static constexpr char const * const name{"AdaDiscriminatedType"};
35613 static constexpr unsigned long variant{914};
35614 static constexpr bool concrete{true};
35615 using subclasses_t = mp::List<>;
35616 using fields_t = mp::List<>;
35617};
35618template <> struct node_from_variant_t<914> { using type = SgAdaDiscriminatedType; };
35619
35620// Class: AdaDiscriminantConstraint
35621template <> struct describe_field_t<SgAdaDiscriminantConstraint,SgExpressionPtrList,&SgAdaDiscriminantConstraint::p_discriminants> {
35623 using field_type = SgExpressionPtrList;
35624 static constexpr size_t position{0};
35625 static constexpr char const * const name{"discriminants"};
35626 static constexpr char const * const typestr{"SgExpressionPtrList"};
35627 static constexpr bool traverse{true};
35628 static constexpr auto mbr_ptr{&SgAdaDiscriminantConstraint::p_discriminants};
35629 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35630 using bind = Desc<SgAdaDiscriminantConstraint, SgExpressionPtrList SgAdaDiscriminantConstraint::*, &SgAdaDiscriminantConstraint::p_discriminants>;
35631};
35634 using base = SgAdaTypeConstraint;
35635 static constexpr char const * const name{"AdaDiscriminantConstraint"};
35636 static constexpr unsigned long variant{915};
35637 static constexpr bool concrete{true};
35638 using subclasses_t = mp::List<>;
35640};
35641template <> struct node_from_variant_t<915> { using type = SgAdaDiscriminantConstraint; };
35642
35643// Class: AdaGenericInstanceDecl
35644template <> struct describe_field_t<SgAdaGenericInstanceDecl,SgName,&SgAdaGenericInstanceDecl::p_name> {
35646 using field_type = SgName;
35647 static constexpr size_t position{0};
35648 static constexpr char const * const name{"name"};
35649 static constexpr char const * const typestr{"SgName"};
35650 static constexpr bool traverse{false};
35651 static constexpr auto mbr_ptr{&SgAdaGenericInstanceDecl::p_name};
35652 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35653 using bind = Desc<SgAdaGenericInstanceDecl, SgName SgAdaGenericInstanceDecl::*, &SgAdaGenericInstanceDecl::p_name>;
35654};
35655template <> struct describe_field_t<SgAdaGenericInstanceDecl,SgDeclarationStatement*,&SgAdaGenericInstanceDecl::p_genericDeclaration> {
35658 static constexpr size_t position{1};
35659 static constexpr char const * const name{"genericDeclaration"};
35660 static constexpr char const * const typestr{"SgDeclarationStatement*"};
35661 static constexpr bool traverse{false};
35662 static constexpr auto mbr_ptr{&SgAdaGenericInstanceDecl::p_genericDeclaration};
35663 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35664 using bind = Desc<SgAdaGenericInstanceDecl, SgDeclarationStatement* SgAdaGenericInstanceDecl::*, &SgAdaGenericInstanceDecl::p_genericDeclaration>;
35665};
35666template <> struct describe_field_t<SgAdaGenericInstanceDecl,SgScopeStatement*,&SgAdaGenericInstanceDecl::p_instantiatedScope> {
35669 static constexpr size_t position{2};
35670 static constexpr char const * const name{"instantiatedScope"};
35671 static constexpr char const * const typestr{"SgScopeStatement*"};
35672 static constexpr bool traverse{true};
35673 static constexpr auto mbr_ptr{&SgAdaGenericInstanceDecl::p_instantiatedScope};
35674 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35675 using bind = Desc<SgAdaGenericInstanceDecl, SgScopeStatement* SgAdaGenericInstanceDecl::*, &SgAdaGenericInstanceDecl::p_instantiatedScope>;
35676};
35677template <> struct describe_field_t<SgAdaGenericInstanceDecl,SgExprListExp*,&SgAdaGenericInstanceDecl::p_actual_parameters> {
35679 using field_type = SgExprListExp*;
35680 static constexpr size_t position{3};
35681 static constexpr char const * const name{"actual_parameters"};
35682 static constexpr char const * const typestr{"SgExprListExp*"};
35683 static constexpr bool traverse{true};
35684 static constexpr auto mbr_ptr{&SgAdaGenericInstanceDecl::p_actual_parameters};
35685 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35686 using bind = Desc<SgAdaGenericInstanceDecl, SgExprListExp* SgAdaGenericInstanceDecl::*, &SgAdaGenericInstanceDecl::p_actual_parameters>;
35687};
35688template <> struct describe_field_t<SgAdaGenericInstanceDecl,SgScopeStatement*,&SgAdaGenericInstanceDecl::p_scope> {
35691 static constexpr size_t position{4};
35692 static constexpr char const * const name{"scope"};
35693 static constexpr char const * const typestr{"SgScopeStatement*"};
35694 static constexpr bool traverse{false};
35695 static constexpr auto mbr_ptr{&SgAdaGenericInstanceDecl::p_scope};
35696 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35697 using bind = Desc<SgAdaGenericInstanceDecl, SgScopeStatement* SgAdaGenericInstanceDecl::*, &SgAdaGenericInstanceDecl::p_scope>;
35698};
35708template <> struct node_from_variant_t<916> { using type = SgAdaGenericInstanceDecl; };
35709
35710// Class: AdaUnscopedBlock
35711template <> struct describe_field_t<SgAdaUnscopedBlock,SgStatementPtrList,&SgAdaUnscopedBlock::p_statements> {
35712 using parent = SgAdaUnscopedBlock;
35713 using field_type = SgStatementPtrList;
35714 static constexpr size_t position{0};
35715 static constexpr char const * const name{"statements"};
35716 static constexpr char const * const typestr{"SgStatementPtrList"};
35717 static constexpr bool traverse{true};
35718 static constexpr auto mbr_ptr{&SgAdaUnscopedBlock::p_statements};
35719 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35720 using bind = Desc<SgAdaUnscopedBlock, SgStatementPtrList SgAdaUnscopedBlock::*, &SgAdaUnscopedBlock::p_statements>;
35721};
35723 using node = SgAdaUnscopedBlock;
35724 using base = SgStatement;
35725 static constexpr char const * const name{"AdaUnscopedBlock"};
35726 static constexpr unsigned long variant{917};
35727 static constexpr bool concrete{true};
35728 using subclasses_t = mp::List<>;
35730};
35731template <> struct node_from_variant_t<917> { using type = SgAdaUnscopedBlock; };
35732
35733// Class: AdaInheritedFunctionSymbol
35734template <> struct describe_field_t<SgAdaInheritedFunctionSymbol,SgFunctionType*,&SgAdaInheritedFunctionSymbol::p_derivedFunctionType> {
35736 using field_type = SgFunctionType*;
35737 static constexpr size_t position{0};
35738 static constexpr char const * const name{"derivedFunctionType"};
35739 static constexpr char const * const typestr{"SgFunctionType*"};
35740 static constexpr bool traverse{false};
35741 static constexpr auto mbr_ptr{&SgAdaInheritedFunctionSymbol::p_derivedFunctionType};
35742 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35743 using bind = Desc<SgAdaInheritedFunctionSymbol, SgFunctionType* SgAdaInheritedFunctionSymbol::*, &SgAdaInheritedFunctionSymbol::p_derivedFunctionType>;
35744};
35745template <> struct describe_field_t<SgAdaInheritedFunctionSymbol,SgNamedType*,&SgAdaInheritedFunctionSymbol::p_associatedDerivedType> {
35747 using field_type = SgNamedType*;
35748 static constexpr size_t position{1};
35749 static constexpr char const * const name{"associatedDerivedType"};
35750 static constexpr char const * const typestr{"SgNamedType*"};
35751 static constexpr bool traverse{false};
35752 static constexpr auto mbr_ptr{&SgAdaInheritedFunctionSymbol::p_associatedDerivedType};
35753 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35754 using bind = Desc<SgAdaInheritedFunctionSymbol, SgNamedType* SgAdaInheritedFunctionSymbol::*, &SgAdaInheritedFunctionSymbol::p_associatedDerivedType>;
35755};
35756template <> struct describe_field_t<SgAdaInheritedFunctionSymbol,SgFunctionSymbol*,&SgAdaInheritedFunctionSymbol::p_publiclyVisibleFunctionSymbol> {
35759 static constexpr size_t position{2};
35760 static constexpr char const * const name{"publiclyVisibleFunctionSymbol"};
35761 static constexpr char const * const typestr{"SgFunctionSymbol*"};
35762 static constexpr bool traverse{false};
35763 static constexpr auto mbr_ptr{&SgAdaInheritedFunctionSymbol::p_publiclyVisibleFunctionSymbol};
35764 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35765 using bind = Desc<SgAdaInheritedFunctionSymbol, SgFunctionSymbol* SgAdaInheritedFunctionSymbol::*, &SgAdaInheritedFunctionSymbol::p_publiclyVisibleFunctionSymbol>;
35766};
35776template <> struct node_from_variant_t<918> { using type = SgAdaInheritedFunctionSymbol; };
35777
35778// Class: AdaProtectedBody
35779template <> struct describe_field_t<SgAdaProtectedBody,SgAdaProtectedSpec*,&SgAdaProtectedBody::p_spec> {
35780 using parent = SgAdaProtectedBody;
35782 static constexpr size_t position{0};
35783 static constexpr char const * const name{"spec"};
35784 static constexpr char const * const typestr{"SgAdaProtectedSpec*"};
35785 static constexpr bool traverse{false};
35786 static constexpr auto mbr_ptr{&SgAdaProtectedBody::p_spec};
35787 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35788 using bind = Desc<SgAdaProtectedBody, SgAdaProtectedSpec* SgAdaProtectedBody::*, &SgAdaProtectedBody::p_spec>;
35789};
35790template <> struct describe_field_t<SgAdaProtectedBody,SgStatementPtrList,&SgAdaProtectedBody::p_statements> {
35791 using parent = SgAdaProtectedBody;
35792 using field_type = SgStatementPtrList;
35793 static constexpr size_t position{1};
35794 static constexpr char const * const name{"statements"};
35795 static constexpr char const * const typestr{"SgStatementPtrList"};
35796 static constexpr bool traverse{true};
35797 static constexpr auto mbr_ptr{&SgAdaProtectedBody::p_statements};
35798 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35799 using bind = Desc<SgAdaProtectedBody, SgStatementPtrList SgAdaProtectedBody::*, &SgAdaProtectedBody::p_statements>;
35800};
35802 using node = SgAdaProtectedBody;
35803 using base = SgScopeStatement;
35804 static constexpr char const * const name{"AdaProtectedBody"};
35805 static constexpr unsigned long variant{919};
35806 static constexpr bool concrete{true};
35807 using subclasses_t = mp::List<>;
35809};
35810template <> struct node_from_variant_t<919> { using type = SgAdaProtectedBody; };
35811
35812// Class: AdaProtectedBodyDecl
35813template <> struct describe_field_t<SgAdaProtectedBodyDecl,SgName,&SgAdaProtectedBodyDecl::p_name> {
35815 using field_type = SgName;
35816 static constexpr size_t position{0};
35817 static constexpr char const * const name{"name"};
35818 static constexpr char const * const typestr{"SgName"};
35819 static constexpr bool traverse{false};
35820 static constexpr auto mbr_ptr{&SgAdaProtectedBodyDecl::p_name};
35821 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35822 using bind = Desc<SgAdaProtectedBodyDecl, SgName SgAdaProtectedBodyDecl::*, &SgAdaProtectedBodyDecl::p_name>;
35823};
35824template <> struct describe_field_t<SgAdaProtectedBodyDecl,SgDeclarationStatement*,&SgAdaProtectedBodyDecl::p_specificationDeclaration> {
35827 static constexpr size_t position{1};
35828 static constexpr char const * const name{"specificationDeclaration"};
35829 static constexpr char const * const typestr{"SgDeclarationStatement*"};
35830 static constexpr bool traverse{false};
35831 static constexpr auto mbr_ptr{&SgAdaProtectedBodyDecl::p_specificationDeclaration};
35832 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35833 using bind = Desc<SgAdaProtectedBodyDecl, SgDeclarationStatement* SgAdaProtectedBodyDecl::*, &SgAdaProtectedBodyDecl::p_specificationDeclaration>;
35834};
35835template <> struct describe_field_t<SgAdaProtectedBodyDecl,SgAdaProtectedBody*,&SgAdaProtectedBodyDecl::p_definition> {
35838 static constexpr size_t position{2};
35839 static constexpr char const * const name{"definition"};
35840 static constexpr char const * const typestr{"SgAdaProtectedBody*"};
35841 static constexpr bool traverse{true};
35842 static constexpr auto mbr_ptr{&SgAdaProtectedBodyDecl::p_definition};
35843 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35844 using bind = Desc<SgAdaProtectedBodyDecl, SgAdaProtectedBody* SgAdaProtectedBodyDecl::*, &SgAdaProtectedBodyDecl::p_definition>;
35845};
35855template <> struct node_from_variant_t<920> { using type = SgAdaProtectedBodyDecl; };
35856
35857// Class: AdaProtectedSpec
35858template <> struct describe_field_t<SgAdaProtectedSpec,SgAdaProtectedBody*,&SgAdaProtectedSpec::p_body> {
35859 using parent = SgAdaProtectedSpec;
35861 static constexpr size_t position{0};
35862 static constexpr char const * const name{"body"};
35863 static constexpr char const * const typestr{"SgAdaProtectedBody*"};
35864 static constexpr bool traverse{false};
35865 static constexpr auto mbr_ptr{&SgAdaProtectedSpec::p_body};
35866 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35867 using bind = Desc<SgAdaProtectedSpec, SgAdaProtectedBody* SgAdaProtectedSpec::*, &SgAdaProtectedSpec::p_body>;
35868};
35869template <> struct describe_field_t<SgAdaProtectedSpec,SgDeclarationStatementPtrList,&SgAdaProtectedSpec::p_declarations> {
35870 using parent = SgAdaProtectedSpec;
35871 using field_type = SgDeclarationStatementPtrList;
35872 static constexpr size_t position{1};
35873 static constexpr char const * const name{"declarations"};
35874 static constexpr char const * const typestr{"SgDeclarationStatementPtrList"};
35875 static constexpr bool traverse{true};
35876 static constexpr auto mbr_ptr{&SgAdaProtectedSpec::p_declarations};
35877 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35878 using bind = Desc<SgAdaProtectedSpec, SgDeclarationStatementPtrList SgAdaProtectedSpec::*, &SgAdaProtectedSpec::p_declarations>;
35879};
35880template <> struct describe_field_t<SgAdaProtectedSpec,bool,&SgAdaProtectedSpec::p_hasPrivate> {
35881 using parent = SgAdaProtectedSpec;
35882 using field_type = bool;
35883 static constexpr size_t position{2};
35884 static constexpr char const * const name{"hasPrivate"};
35885 static constexpr char const * const typestr{"bool"};
35886 static constexpr bool traverse{false};
35887 static constexpr auto mbr_ptr{&SgAdaProtectedSpec::p_hasPrivate};
35888 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35889 using bind = Desc<SgAdaProtectedSpec, bool SgAdaProtectedSpec::*, &SgAdaProtectedSpec::p_hasPrivate>;
35890};
35892 using node = SgAdaProtectedSpec;
35893 using base = SgScopeStatement;
35894 static constexpr char const * const name{"AdaProtectedSpec"};
35895 static constexpr unsigned long variant{921};
35896 static constexpr bool concrete{true};
35897 using subclasses_t = mp::List<>;
35899};
35900template <> struct node_from_variant_t<921> { using type = SgAdaProtectedSpec; };
35901
35902// Class: AdaProtectedSpecDecl
35903template <> struct describe_field_t<SgAdaProtectedSpecDecl,SgName,&SgAdaProtectedSpecDecl::p_name> {
35905 using field_type = SgName;
35906 static constexpr size_t position{0};
35907 static constexpr char const * const name{"name"};
35908 static constexpr char const * const typestr{"SgName"};
35909 static constexpr bool traverse{false};
35910 static constexpr auto mbr_ptr{&SgAdaProtectedSpecDecl::p_name};
35911 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35912 using bind = Desc<SgAdaProtectedSpecDecl, SgName SgAdaProtectedSpecDecl::*, &SgAdaProtectedSpecDecl::p_name>;
35913};
35914template <> struct describe_field_t<SgAdaProtectedSpecDecl,SgAdaProtectedSpec*,&SgAdaProtectedSpecDecl::p_definition> {
35917 static constexpr size_t position{1};
35918 static constexpr char const * const name{"definition"};
35919 static constexpr char const * const typestr{"SgAdaProtectedSpec*"};
35920 static constexpr bool traverse{true};
35921 static constexpr auto mbr_ptr{&SgAdaProtectedSpecDecl::p_definition};
35922 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35923 using bind = Desc<SgAdaProtectedSpecDecl, SgAdaProtectedSpec* SgAdaProtectedSpecDecl::*, &SgAdaProtectedSpecDecl::p_definition>;
35924};
35925template <> struct describe_field_t<SgAdaProtectedSpecDecl,SgAdaProtectedType*,&SgAdaProtectedSpecDecl::p_type> {
35928 static constexpr size_t position{2};
35929 static constexpr char const * const name{"type"};
35930 static constexpr char const * const typestr{"SgAdaProtectedType*"};
35931 static constexpr bool traverse{false};
35932 static constexpr auto mbr_ptr{&SgAdaProtectedSpecDecl::p_type};
35933 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35934 using bind = Desc<SgAdaProtectedSpecDecl, SgAdaProtectedType* SgAdaProtectedSpecDecl::*, &SgAdaProtectedSpecDecl::p_type>;
35935};
35939 static constexpr char const * const name{"AdaProtectedSpecDecl"};
35940 static constexpr unsigned long variant{922};
35941 static constexpr bool concrete{true};
35942 using subclasses_t = mp::List<>;
35944};
35945template <> struct node_from_variant_t<922> { using type = SgAdaProtectedSpecDecl; };
35946
35947// Class: AdaProtectedSymbol
35948template <> struct describe_field_t<SgAdaProtectedSymbol,SgDeclarationStatement*,&SgAdaProtectedSymbol::p_declaration> {
35951 static constexpr size_t position{0};
35952 static constexpr char const * const name{"declaration"};
35953 static constexpr char const * const typestr{"SgDeclarationStatement*"};
35954 static constexpr bool traverse{true};
35955 static constexpr auto mbr_ptr{&SgAdaProtectedSymbol::p_declaration};
35956 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35957 using bind = Desc<SgAdaProtectedSymbol, SgDeclarationStatement* SgAdaProtectedSymbol::*, &SgAdaProtectedSymbol::p_declaration>;
35958};
35960 using node = SgAdaProtectedSymbol;
35961 using base = SgSymbol;
35962 static constexpr char const * const name{"AdaProtectedSymbol"};
35963 static constexpr unsigned long variant{923};
35964 static constexpr bool concrete{true};
35965 using subclasses_t = mp::List<>;
35967};
35968template <> struct node_from_variant_t<923> { using type = SgAdaProtectedSymbol; };
35969
35970// Class: AdaProtectedRefExp
35971template <> struct describe_field_t<SgAdaProtectedRefExp,SgAdaProtectedSymbol*,&SgAdaProtectedRefExp::p_symbol> {
35974 static constexpr size_t position{0};
35975 static constexpr char const * const name{"symbol"};
35976 static constexpr char const * const typestr{"SgAdaProtectedSymbol*"};
35977 static constexpr bool traverse{false};
35978 static constexpr auto mbr_ptr{&SgAdaProtectedRefExp::p_symbol};
35979 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
35980 using bind = Desc<SgAdaProtectedRefExp, SgAdaProtectedSymbol* SgAdaProtectedRefExp::*, &SgAdaProtectedRefExp::p_symbol>;
35981};
35983 using node = SgAdaProtectedRefExp;
35984 using base = SgExpression;
35985 static constexpr char const * const name{"AdaProtectedRefExp"};
35986 static constexpr unsigned long variant{924};
35987 static constexpr bool concrete{true};
35988 using subclasses_t = mp::List<>;
35990};
35991template <> struct node_from_variant_t<924> { using type = SgAdaProtectedRefExp; };
35992
35993// Class: AdaProtectedType
35995 using node = SgAdaProtectedType;
35996 using base = SgNamedType;
35997 static constexpr char const * const name{"AdaProtectedType"};
35998 static constexpr unsigned long variant{925};
35999 static constexpr bool concrete{true};
36000 using subclasses_t = mp::List<>;
36001 using fields_t = mp::List<>;
36002};
36003template <> struct node_from_variant_t<925> { using type = SgAdaProtectedType; };
36004
36005// Class: AdaProtectedTypeDecl
36006template <> struct describe_field_t<SgAdaProtectedTypeDecl,SgName,&SgAdaProtectedTypeDecl::p_name> {
36008 using field_type = SgName;
36009 static constexpr size_t position{0};
36010 static constexpr char const * const name{"name"};
36011 static constexpr char const * const typestr{"SgName"};
36012 static constexpr bool traverse{false};
36013 static constexpr auto mbr_ptr{&SgAdaProtectedTypeDecl::p_name};
36014 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36015 using bind = Desc<SgAdaProtectedTypeDecl, SgName SgAdaProtectedTypeDecl::*, &SgAdaProtectedTypeDecl::p_name>;
36016};
36017template <> struct describe_field_t<SgAdaProtectedTypeDecl,SgAdaProtectedSpec*,&SgAdaProtectedTypeDecl::p_definition> {
36020 static constexpr size_t position{1};
36021 static constexpr char const * const name{"definition"};
36022 static constexpr char const * const typestr{"SgAdaProtectedSpec*"};
36023 static constexpr bool traverse{true};
36024 static constexpr auto mbr_ptr{&SgAdaProtectedTypeDecl::p_definition};
36025 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36026 using bind = Desc<SgAdaProtectedTypeDecl, SgAdaProtectedSpec* SgAdaProtectedTypeDecl::*, &SgAdaProtectedTypeDecl::p_definition>;
36027};
36028template <> struct describe_field_t<SgAdaProtectedTypeDecl,SgAdaProtectedType*,&SgAdaProtectedTypeDecl::p_type> {
36031 static constexpr size_t position{2};
36032 static constexpr char const * const name{"type"};
36033 static constexpr char const * const typestr{"SgAdaProtectedType*"};
36034 static constexpr bool traverse{false};
36035 static constexpr auto mbr_ptr{&SgAdaProtectedTypeDecl::p_type};
36036 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36037 using bind = Desc<SgAdaProtectedTypeDecl, SgAdaProtectedType* SgAdaProtectedTypeDecl::*, &SgAdaProtectedTypeDecl::p_type>;
36038};
36039template <> struct describe_field_t<SgAdaProtectedTypeDecl,SgScopeStatement*,&SgAdaProtectedTypeDecl::p_scope> {
36042 static constexpr size_t position{3};
36043 static constexpr char const * const name{"scope"};
36044 static constexpr char const * const typestr{"SgScopeStatement*"};
36045 static constexpr bool traverse{false};
36046 static constexpr auto mbr_ptr{&SgAdaProtectedTypeDecl::p_scope};
36047 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36048 using bind = Desc<SgAdaProtectedTypeDecl, SgScopeStatement* SgAdaProtectedTypeDecl::*, &SgAdaProtectedTypeDecl::p_scope>;
36049};
36059template <> struct node_from_variant_t<926> { using type = SgAdaProtectedTypeDecl; };
36060
36061// Class: AdaDigitsConstraint
36062template <> struct describe_field_t<SgAdaDigitsConstraint,SgExpression*,&SgAdaDigitsConstraint::p_digits> {
36064 using field_type = SgExpression*;
36065 static constexpr size_t position{0};
36066 static constexpr char const * const name{"digits"};
36067 static constexpr char const * const typestr{"SgExpression*"};
36068 static constexpr bool traverse{true};
36069 static constexpr auto mbr_ptr{&SgAdaDigitsConstraint::p_digits};
36070 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36071 using bind = Desc<SgAdaDigitsConstraint, SgExpression* SgAdaDigitsConstraint::*, &SgAdaDigitsConstraint::p_digits>;
36072};
36073template <> struct describe_field_t<SgAdaDigitsConstraint,SgAdaTypeConstraint*,&SgAdaDigitsConstraint::p_subConstraint> {
36076 static constexpr size_t position{1};
36077 static constexpr char const * const name{"subConstraint"};
36078 static constexpr char const * const typestr{"SgAdaTypeConstraint*"};
36079 static constexpr bool traverse{true};
36080 static constexpr auto mbr_ptr{&SgAdaDigitsConstraint::p_subConstraint};
36081 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36082 using bind = Desc<SgAdaDigitsConstraint, SgAdaTypeConstraint* SgAdaDigitsConstraint::*, &SgAdaDigitsConstraint::p_subConstraint>;
36083};
36086 using base = SgAdaTypeConstraint;
36087 static constexpr char const * const name{"AdaDigitsConstraint"};
36088 static constexpr unsigned long variant{927};
36089 static constexpr bool concrete{true};
36090 using subclasses_t = mp::List<>;
36092};
36093template <> struct node_from_variant_t<927> { using type = SgAdaDigitsConstraint; };
36094
36095// Class: AdaAncestorInitializer
36096template <> struct describe_field_t<SgAdaAncestorInitializer,SgExpression*,&SgAdaAncestorInitializer::p_ancestor> {
36098 using field_type = SgExpression*;
36099 static constexpr size_t position{0};
36100 static constexpr char const * const name{"ancestor"};
36101 static constexpr char const * const typestr{"SgExpression*"};
36102 static constexpr bool traverse{true};
36103 static constexpr auto mbr_ptr{&SgAdaAncestorInitializer::p_ancestor};
36104 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36105 using bind = Desc<SgAdaAncestorInitializer, SgExpression* SgAdaAncestorInitializer::*, &SgAdaAncestorInitializer::p_ancestor>;
36106};
36109 using base = SgInitializer;
36110 static constexpr char const * const name{"AdaAncestorInitializer"};
36111 static constexpr unsigned long variant{928};
36112 static constexpr bool concrete{true};
36113 using subclasses_t = mp::List<>;
36115};
36116template <> struct node_from_variant_t<928> { using type = SgAdaAncestorInitializer; };
36117
36118// Class: AdaDeltaConstraint
36119template <> struct describe_field_t<SgAdaDeltaConstraint,SgExpression*,&SgAdaDeltaConstraint::p_delta> {
36121 using field_type = SgExpression*;
36122 static constexpr size_t position{0};
36123 static constexpr char const * const name{"delta"};
36124 static constexpr char const * const typestr{"SgExpression*"};
36125 static constexpr bool traverse{true};
36126 static constexpr auto mbr_ptr{&SgAdaDeltaConstraint::p_delta};
36127 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36128 using bind = Desc<SgAdaDeltaConstraint, SgExpression* SgAdaDeltaConstraint::*, &SgAdaDeltaConstraint::p_delta>;
36129};
36130template <> struct describe_field_t<SgAdaDeltaConstraint,SgAdaTypeConstraint*,&SgAdaDeltaConstraint::p_subConstraint> {
36133 static constexpr size_t position{1};
36134 static constexpr char const * const name{"subConstraint"};
36135 static constexpr char const * const typestr{"SgAdaTypeConstraint*"};
36136 static constexpr bool traverse{true};
36137 static constexpr auto mbr_ptr{&SgAdaDeltaConstraint::p_subConstraint};
36138 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36139 using bind = Desc<SgAdaDeltaConstraint, SgAdaTypeConstraint* SgAdaDeltaConstraint::*, &SgAdaDeltaConstraint::p_subConstraint>;
36140};
36141template <> struct describe_field_t<SgAdaDeltaConstraint,bool,&SgAdaDeltaConstraint::p_isDecimal> {
36143 using field_type = bool;
36144 static constexpr size_t position{2};
36145 static constexpr char const * const name{"isDecimal"};
36146 static constexpr char const * const typestr{"bool"};
36147 static constexpr bool traverse{false};
36148 static constexpr auto mbr_ptr{&SgAdaDeltaConstraint::p_isDecimal};
36149 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36150 using bind = Desc<SgAdaDeltaConstraint, bool SgAdaDeltaConstraint::*, &SgAdaDeltaConstraint::p_isDecimal>;
36151};
36153 using node = SgAdaDeltaConstraint;
36154 using base = SgAdaTypeConstraint;
36155 static constexpr char const * const name{"AdaDeltaConstraint"};
36156 static constexpr unsigned long variant{929};
36157 static constexpr bool concrete{true};
36158 using subclasses_t = mp::List<>;
36160};
36161template <> struct node_from_variant_t<929> { using type = SgAdaDeltaConstraint; };
36162
36163// Class: AdaSubroutineType
36164template <> struct describe_field_t<SgAdaSubroutineType,SgFunctionParameterList*,&SgAdaSubroutineType::p_parameterList> {
36167 static constexpr size_t position{0};
36168 static constexpr char const * const name{"parameterList"};
36169 static constexpr char const * const typestr{"SgFunctionParameterList*"};
36170 static constexpr bool traverse{true};
36171 static constexpr auto mbr_ptr{&SgAdaSubroutineType::p_parameterList};
36172 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36173 using bind = Desc<SgAdaSubroutineType, SgFunctionParameterList* SgAdaSubroutineType::*, &SgAdaSubroutineType::p_parameterList>;
36174};
36175template <> struct describe_field_t<SgAdaSubroutineType,SgFunctionParameterScope*,&SgAdaSubroutineType::p_functionParameterScope> {
36178 static constexpr size_t position{1};
36179 static constexpr char const * const name{"functionParameterScope"};
36180 static constexpr char const * const typestr{"SgFunctionParameterScope*"};
36181 static constexpr bool traverse{false};
36182 static constexpr auto mbr_ptr{&SgAdaSubroutineType::p_functionParameterScope};
36183 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36184 using bind = Desc<SgAdaSubroutineType, SgFunctionParameterScope* SgAdaSubroutineType::*, &SgAdaSubroutineType::p_functionParameterScope>;
36185};
36186template <> struct describe_field_t<SgAdaSubroutineType,SgType*,&SgAdaSubroutineType::p_return_type> {
36188 using field_type = SgType*;
36189 static constexpr size_t position{2};
36190 static constexpr char const * const name{"return_type"};
36191 static constexpr char const * const typestr{"SgType*"};
36192 static constexpr bool traverse{true};
36193 static constexpr auto mbr_ptr{&SgAdaSubroutineType::p_return_type};
36194 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36195 using bind = Desc<SgAdaSubroutineType, SgType* SgAdaSubroutineType::*, &SgAdaSubroutineType::p_return_type>;
36196};
36197template <> struct describe_field_t<SgAdaSubroutineType,bool,&SgAdaSubroutineType::p_is_protected> {
36199 using field_type = bool;
36200 static constexpr size_t position{3};
36201 static constexpr char const * const name{"is_protected"};
36202 static constexpr char const * const typestr{"bool"};
36203 static constexpr bool traverse{false};
36204 static constexpr auto mbr_ptr{&SgAdaSubroutineType::p_is_protected};
36205 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36206 using bind = Desc<SgAdaSubroutineType, bool SgAdaSubroutineType::*, &SgAdaSubroutineType::p_is_protected>;
36207};
36217template <> struct node_from_variant_t<930> { using type = SgAdaSubroutineType; };
36218
36219// Class: AdaGenericInstanceSymbol
36220template <> struct describe_field_t<SgAdaGenericInstanceSymbol,SgAdaGenericInstanceDecl*,&SgAdaGenericInstanceSymbol::p_declaration> {
36223 static constexpr size_t position{0};
36224 static constexpr char const * const name{"declaration"};
36225 static constexpr char const * const typestr{"SgAdaGenericInstanceDecl*"};
36226 static constexpr bool traverse{true};
36227 static constexpr auto mbr_ptr{&SgAdaGenericInstanceSymbol::p_declaration};
36228 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36229 using bind = Desc<SgAdaGenericInstanceSymbol, SgAdaGenericInstanceDecl* SgAdaGenericInstanceSymbol::*, &SgAdaGenericInstanceSymbol::p_declaration>;
36230};
36233 using base = SgSymbol;
36234 static constexpr char const * const name{"AdaGenericInstanceSymbol"};
36235 static constexpr unsigned long variant{931};
36236 static constexpr bool concrete{true};
36237 using subclasses_t = mp::List<>;
36239};
36240template <> struct node_from_variant_t<931> { using type = SgAdaGenericInstanceSymbol; };
36241
36242// Class: AdaFormalPackageDecl
36243template <> struct describe_field_t<SgAdaFormalPackageDecl,SgName,&SgAdaFormalPackageDecl::p_name> {
36245 using field_type = SgName;
36246 static constexpr size_t position{0};
36247 static constexpr char const * const name{"name"};
36248 static constexpr char const * const typestr{"SgName"};
36249 static constexpr bool traverse{false};
36250 static constexpr auto mbr_ptr{&SgAdaFormalPackageDecl::p_name};
36251 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36252 using bind = Desc<SgAdaFormalPackageDecl, SgName SgAdaFormalPackageDecl::*, &SgAdaFormalPackageDecl::p_name>;
36253};
36254template <> struct describe_field_t<SgAdaFormalPackageDecl,SgDeclarationStatement*,&SgAdaFormalPackageDecl::p_declaration> {
36257 static constexpr size_t position{1};
36258 static constexpr char const * const name{"declaration"};
36259 static constexpr char const * const typestr{"SgDeclarationStatement*"};
36260 static constexpr bool traverse{false};
36261 static constexpr auto mbr_ptr{&SgAdaFormalPackageDecl::p_declaration};
36262 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36263 using bind = Desc<SgAdaFormalPackageDecl, SgDeclarationStatement* SgAdaFormalPackageDecl::*, &SgAdaFormalPackageDecl::p_declaration>;
36264};
36265template <> struct describe_field_t<SgAdaFormalPackageDecl,SgExprListExp*,&SgAdaFormalPackageDecl::p_actual_parameters> {
36267 using field_type = SgExprListExp*;
36268 static constexpr size_t position{2};
36269 static constexpr char const * const name{"actual_parameters"};
36270 static constexpr char const * const typestr{"SgExprListExp*"};
36271 static constexpr bool traverse{false};
36272 static constexpr auto mbr_ptr{&SgAdaFormalPackageDecl::p_actual_parameters};
36273 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36274 using bind = Desc<SgAdaFormalPackageDecl, SgExprListExp* SgAdaFormalPackageDecl::*, &SgAdaFormalPackageDecl::p_actual_parameters>;
36275};
36276template <> struct describe_field_t<SgAdaFormalPackageDecl,SgDeclarationStatement*,&SgAdaFormalPackageDecl::p_prototype> {
36279 static constexpr size_t position{3};
36280 static constexpr char const * const name{"prototype"};
36281 static constexpr char const * const typestr{"SgDeclarationStatement*"};
36282 static constexpr bool traverse{false};
36283 static constexpr auto mbr_ptr{&SgAdaFormalPackageDecl::p_prototype};
36284 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36285 using bind = Desc<SgAdaFormalPackageDecl, SgDeclarationStatement* SgAdaFormalPackageDecl::*, &SgAdaFormalPackageDecl::p_prototype>;
36286};
36287template <> struct describe_field_t<SgAdaFormalPackageDecl,SgScopeStatement*,&SgAdaFormalPackageDecl::p_prototypeScope> {
36290 static constexpr size_t position{4};
36291 static constexpr char const * const name{"prototypeScope"};
36292 static constexpr char const * const typestr{"SgScopeStatement*"};
36293 static constexpr bool traverse{false};
36294 static constexpr auto mbr_ptr{&SgAdaFormalPackageDecl::p_prototypeScope};
36295 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36296 using bind = Desc<SgAdaFormalPackageDecl, SgScopeStatement* SgAdaFormalPackageDecl::*, &SgAdaFormalPackageDecl::p_prototypeScope>;
36297};
36307template <> struct node_from_variant_t<932> { using type = SgAdaFormalPackageDecl; };
36308
36309// Class: AdaFormalPackageSymbol
36310template <> struct describe_field_t<SgAdaFormalPackageSymbol,SgAdaFormalPackageDecl*,&SgAdaFormalPackageSymbol::p_declaration> {
36313 static constexpr size_t position{0};
36314 static constexpr char const * const name{"declaration"};
36315 static constexpr char const * const typestr{"SgAdaFormalPackageDecl*"};
36316 static constexpr bool traverse{true};
36317 static constexpr auto mbr_ptr{&SgAdaFormalPackageSymbol::p_declaration};
36318 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36319 using bind = Desc<SgAdaFormalPackageSymbol, SgAdaFormalPackageDecl* SgAdaFormalPackageSymbol::*, &SgAdaFormalPackageSymbol::p_declaration>;
36320};
36323 using base = SgSymbol;
36324 static constexpr char const * const name{"AdaFormalPackageSymbol"};
36325 static constexpr unsigned long variant{933};
36326 static constexpr bool concrete{true};
36327 using subclasses_t = mp::List<>;
36329};
36330template <> struct node_from_variant_t<933> { using type = SgAdaFormalPackageSymbol; };
36331
36332// Class: AsmJvmAttributeTable
36333template <> struct describe_field_t<SgAsmJvmAttributeTable,SgAsmJvmAttributePtrList,&SgAsmJvmAttributeTable::p_attributes> {
36335 using field_type = SgAsmJvmAttributePtrList;
36336 static constexpr size_t position{0};
36337 static constexpr char const * const name{"attributes"};
36338 static constexpr char const * const typestr{"SgAsmJvmAttributePtrList"};
36339 static constexpr bool traverse{true};
36340 static constexpr auto mbr_ptr{&SgAsmJvmAttributeTable::p_attributes};
36341 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36342 using bind = Desc<SgAsmJvmAttributeTable, SgAsmJvmAttributePtrList SgAsmJvmAttributeTable::*, &SgAsmJvmAttributeTable::p_attributes>;
36343};
36346 using base = SgAsmGenericSection;
36347 static constexpr char const * const name{"AsmJvmAttributeTable"};
36348 static constexpr unsigned long variant{934};
36349 static constexpr bool concrete{true};
36350 using subclasses_t = mp::List<>;
36352};
36353template <> struct node_from_variant_t<934> { using type = SgAsmJvmAttributeTable; };
36354
36355// Class: AsmJvmMethodTable
36356template <> struct describe_field_t<SgAsmJvmMethodTable,SgAsmJvmMethodPtrList,&SgAsmJvmMethodTable::p_methods> {
36358 using field_type = SgAsmJvmMethodPtrList;
36359 static constexpr size_t position{0};
36360 static constexpr char const * const name{"methods"};
36361 static constexpr char const * const typestr{"SgAsmJvmMethodPtrList"};
36362 static constexpr bool traverse{true};
36363 static constexpr auto mbr_ptr{&SgAsmJvmMethodTable::p_methods};
36364 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36365 using bind = Desc<SgAsmJvmMethodTable, SgAsmJvmMethodPtrList SgAsmJvmMethodTable::*, &SgAsmJvmMethodTable::p_methods>;
36366};
36368 using node = SgAsmJvmMethodTable;
36369 using base = SgAsmGenericSection;
36370 static constexpr char const * const name{"AsmJvmMethodTable"};
36371 static constexpr unsigned long variant{935};
36372 static constexpr bool concrete{true};
36373 using subclasses_t = mp::List<>;
36375};
36376template <> struct node_from_variant_t<935> { using type = SgAsmJvmMethodTable; };
36377
36378// Class: AsmJvmField
36379template <> struct describe_field_t<SgAsmJvmField,uint16_t,&SgAsmJvmField::p_access_flags> {
36380 using parent = SgAsmJvmField;
36381 using field_type = uint16_t;
36382 static constexpr size_t position{0};
36383 static constexpr char const * const name{"access_flags"};
36384 static constexpr char const * const typestr{"uint16_t"};
36385 static constexpr bool traverse{false};
36386 static constexpr auto mbr_ptr{&SgAsmJvmField::p_access_flags};
36387 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36388 using bind = Desc<SgAsmJvmField, uint16_t SgAsmJvmField::*, &SgAsmJvmField::p_access_flags>;
36389};
36390template <> struct describe_field_t<SgAsmJvmField,uint16_t,&SgAsmJvmField::p_name_index> {
36391 using parent = SgAsmJvmField;
36392 using field_type = uint16_t;
36393 static constexpr size_t position{1};
36394 static constexpr char const * const name{"name_index"};
36395 static constexpr char const * const typestr{"uint16_t"};
36396 static constexpr bool traverse{false};
36397 static constexpr auto mbr_ptr{&SgAsmJvmField::p_name_index};
36398 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36399 using bind = Desc<SgAsmJvmField, uint16_t SgAsmJvmField::*, &SgAsmJvmField::p_name_index>;
36400};
36401template <> struct describe_field_t<SgAsmJvmField,uint16_t,&SgAsmJvmField::p_descriptor_index> {
36402 using parent = SgAsmJvmField;
36403 using field_type = uint16_t;
36404 static constexpr size_t position{2};
36405 static constexpr char const * const name{"descriptor_index"};
36406 static constexpr char const * const typestr{"uint16_t"};
36407 static constexpr bool traverse{false};
36408 static constexpr auto mbr_ptr{&SgAsmJvmField::p_descriptor_index};
36409 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36410 using bind = Desc<SgAsmJvmField, uint16_t SgAsmJvmField::*, &SgAsmJvmField::p_descriptor_index>;
36411};
36412template <> struct describe_field_t<SgAsmJvmField,SgAsmJvmAttributeTable*,&SgAsmJvmField::p_attribute_table> {
36413 using parent = SgAsmJvmField;
36415 static constexpr size_t position{3};
36416 static constexpr char const * const name{"attribute_table"};
36417 static constexpr char const * const typestr{"SgAsmJvmAttributeTable*"};
36418 static constexpr bool traverse{true};
36419 static constexpr auto mbr_ptr{&SgAsmJvmField::p_attribute_table};
36420 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36421 using bind = Desc<SgAsmJvmField, SgAsmJvmAttributeTable* SgAsmJvmField::*, &SgAsmJvmField::p_attribute_table>;
36422};
36432template <> struct node_from_variant_t<936> { using type = SgAsmJvmField; };
36433
36434// Class: AsmJvmFieldTable
36435template <> struct describe_field_t<SgAsmJvmFieldTable,SgAsmJvmFieldPtrList,&SgAsmJvmFieldTable::p_fields> {
36436 using parent = SgAsmJvmFieldTable;
36437 using field_type = SgAsmJvmFieldPtrList;
36438 static constexpr size_t position{0};
36439 static constexpr char const * const name{"fields"};
36440 static constexpr char const * const typestr{"SgAsmJvmFieldPtrList"};
36441 static constexpr bool traverse{true};
36442 static constexpr auto mbr_ptr{&SgAsmJvmFieldTable::p_fields};
36443 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36444 using bind = Desc<SgAsmJvmFieldTable, SgAsmJvmFieldPtrList SgAsmJvmFieldTable::*, &SgAsmJvmFieldTable::p_fields>;
36445};
36447 using node = SgAsmJvmFieldTable;
36448 using base = SgAsmGenericSection;
36449 static constexpr char const * const name{"AsmJvmFieldTable"};
36450 static constexpr unsigned long variant{937};
36451 static constexpr bool concrete{true};
36452 using subclasses_t = mp::List<>;
36454};
36455template <> struct node_from_variant_t<937> { using type = SgAsmJvmFieldTable; };
36456
36457// Class: AsmJvmExceptionHandler
36458template <> struct describe_field_t<SgAsmJvmExceptionHandler,uint16_t,&SgAsmJvmExceptionHandler::p_start_pc> {
36460 using field_type = uint16_t;
36461 static constexpr size_t position{0};
36462 static constexpr char const * const name{"start_pc"};
36463 static constexpr char const * const typestr{"uint16_t"};
36464 static constexpr bool traverse{false};
36465 static constexpr auto mbr_ptr{&SgAsmJvmExceptionHandler::p_start_pc};
36466 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36467 using bind = Desc<SgAsmJvmExceptionHandler, uint16_t SgAsmJvmExceptionHandler::*, &SgAsmJvmExceptionHandler::p_start_pc>;
36468};
36469template <> struct describe_field_t<SgAsmJvmExceptionHandler,uint16_t,&SgAsmJvmExceptionHandler::p_end_pc> {
36471 using field_type = uint16_t;
36472 static constexpr size_t position{1};
36473 static constexpr char const * const name{"end_pc"};
36474 static constexpr char const * const typestr{"uint16_t"};
36475 static constexpr bool traverse{false};
36476 static constexpr auto mbr_ptr{&SgAsmJvmExceptionHandler::p_end_pc};
36477 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36478 using bind = Desc<SgAsmJvmExceptionHandler, uint16_t SgAsmJvmExceptionHandler::*, &SgAsmJvmExceptionHandler::p_end_pc>;
36479};
36480template <> struct describe_field_t<SgAsmJvmExceptionHandler,uint16_t,&SgAsmJvmExceptionHandler::p_handler_pc> {
36482 using field_type = uint16_t;
36483 static constexpr size_t position{2};
36484 static constexpr char const * const name{"handler_pc"};
36485 static constexpr char const * const typestr{"uint16_t"};
36486 static constexpr bool traverse{false};
36487 static constexpr auto mbr_ptr{&SgAsmJvmExceptionHandler::p_handler_pc};
36488 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36489 using bind = Desc<SgAsmJvmExceptionHandler, uint16_t SgAsmJvmExceptionHandler::*, &SgAsmJvmExceptionHandler::p_handler_pc>;
36490};
36491template <> struct describe_field_t<SgAsmJvmExceptionHandler,uint16_t,&SgAsmJvmExceptionHandler::p_catch_type> {
36493 using field_type = uint16_t;
36494 static constexpr size_t position{3};
36495 static constexpr char const * const name{"catch_type"};
36496 static constexpr char const * const typestr{"uint16_t"};
36497 static constexpr bool traverse{false};
36498 static constexpr auto mbr_ptr{&SgAsmJvmExceptionHandler::p_catch_type};
36499 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36500 using bind = Desc<SgAsmJvmExceptionHandler, uint16_t SgAsmJvmExceptionHandler::*, &SgAsmJvmExceptionHandler::p_catch_type>;
36501};
36511template <> struct node_from_variant_t<938> { using type = SgAsmJvmExceptionHandler; };
36512
36513// Class: AsmJvmExceptionTable
36514template <> struct describe_field_t<SgAsmJvmExceptionTable,SgAsmJvmExceptionHandlerPtrList,&SgAsmJvmExceptionTable::p_handlers> {
36516 using field_type = SgAsmJvmExceptionHandlerPtrList;
36517 static constexpr size_t position{0};
36518 static constexpr char const * const name{"handlers"};
36519 static constexpr char const * const typestr{"SgAsmJvmExceptionHandlerPtrList"};
36520 static constexpr bool traverse{false};
36521 static constexpr auto mbr_ptr{&SgAsmJvmExceptionTable::p_handlers};
36522 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36523 using bind = Desc<SgAsmJvmExceptionTable, SgAsmJvmExceptionHandlerPtrList SgAsmJvmExceptionTable::*, &SgAsmJvmExceptionTable::p_handlers>;
36524};
36527 using base = SgAsmJvmNode;
36528 static constexpr char const * const name{"AsmJvmExceptionTable"};
36529 static constexpr unsigned long variant{939};
36530 static constexpr bool concrete{true};
36531 using subclasses_t = mp::List<>;
36533};
36534template <> struct node_from_variant_t<939> { using type = SgAsmJvmExceptionTable; };
36535
36536// Class: AsmJvmClass
36537template <> struct describe_node_t<SgAsmJvmClass> {
36538 using node = SgAsmJvmClass;
36539 using base = SgAsmJvmNode;
36540 static constexpr char const * const name{"AsmJvmClass"};
36541 static constexpr unsigned long variant{940};
36542 static constexpr bool concrete{true};
36543 using subclasses_t = mp::List<>;
36544 using fields_t = mp::List<>;
36545};
36546template <> struct node_from_variant_t<940> { using type = SgAsmJvmClass; };
36547
36548// Class: AsmJvmLineNumberEntry
36549template <> struct describe_field_t<SgAsmJvmLineNumberEntry,uint16_t,&SgAsmJvmLineNumberEntry::p_start_pc> {
36551 using field_type = uint16_t;
36552 static constexpr size_t position{0};
36553 static constexpr char const * const name{"start_pc"};
36554 static constexpr char const * const typestr{"uint16_t"};
36555 static constexpr bool traverse{false};
36556 static constexpr auto mbr_ptr{&SgAsmJvmLineNumberEntry::p_start_pc};
36557 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36558 using bind = Desc<SgAsmJvmLineNumberEntry, uint16_t SgAsmJvmLineNumberEntry::*, &SgAsmJvmLineNumberEntry::p_start_pc>;
36559};
36560template <> struct describe_field_t<SgAsmJvmLineNumberEntry,uint16_t,&SgAsmJvmLineNumberEntry::p_line_number> {
36562 using field_type = uint16_t;
36563 static constexpr size_t position{1};
36564 static constexpr char const * const name{"line_number"};
36565 static constexpr char const * const typestr{"uint16_t"};
36566 static constexpr bool traverse{false};
36567 static constexpr auto mbr_ptr{&SgAsmJvmLineNumberEntry::p_line_number};
36568 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36569 using bind = Desc<SgAsmJvmLineNumberEntry, uint16_t SgAsmJvmLineNumberEntry::*, &SgAsmJvmLineNumberEntry::p_line_number>;
36570};
36573 using base = SgAsmJvmNode;
36574 static constexpr char const * const name{"AsmJvmLineNumberEntry"};
36575 static constexpr unsigned long variant{941};
36576 static constexpr bool concrete{true};
36577 using subclasses_t = mp::List<>;
36579};
36580template <> struct node_from_variant_t<941> { using type = SgAsmJvmLineNumberEntry; };
36581
36582// Class: AsmJvmLineNumberTable
36583template <> struct describe_field_t<SgAsmJvmLineNumberTable,SgAsmJvmLineNumberEntryPtrList,&SgAsmJvmLineNumberTable::p_line_number_table> {
36585 using field_type = SgAsmJvmLineNumberEntryPtrList;
36586 static constexpr size_t position{0};
36587 static constexpr char const * const name{"line_number_table"};
36588 static constexpr char const * const typestr{"SgAsmJvmLineNumberEntryPtrList"};
36589 static constexpr bool traverse{false};
36590 static constexpr auto mbr_ptr{&SgAsmJvmLineNumberTable::p_line_number_table};
36591 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36592 using bind = Desc<SgAsmJvmLineNumberTable, SgAsmJvmLineNumberEntryPtrList SgAsmJvmLineNumberTable::*, &SgAsmJvmLineNumberTable::p_line_number_table>;
36593};
36596 using base = SgAsmJvmAttribute;
36597 static constexpr char const * const name{"AsmJvmLineNumberTable"};
36598 static constexpr unsigned long variant{942};
36599 static constexpr bool concrete{true};
36600 using subclasses_t = mp::List<>;
36602};
36603template <> struct node_from_variant_t<942> { using type = SgAsmJvmLineNumberTable; };
36604
36605// Class: AsmJvmInnerClassesEntry
36606template <> struct describe_field_t<SgAsmJvmInnerClassesEntry,uint16_t,&SgAsmJvmInnerClassesEntry::p_inner_class_info_index> {
36608 using field_type = uint16_t;
36609 static constexpr size_t position{0};
36610 static constexpr char const * const name{"inner_class_info_index"};
36611 static constexpr char const * const typestr{"uint16_t"};
36612 static constexpr bool traverse{false};
36613 static constexpr auto mbr_ptr{&SgAsmJvmInnerClassesEntry::p_inner_class_info_index};
36614 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36615 using bind = Desc<SgAsmJvmInnerClassesEntry, uint16_t SgAsmJvmInnerClassesEntry::*, &SgAsmJvmInnerClassesEntry::p_inner_class_info_index>;
36616};
36617template <> struct describe_field_t<SgAsmJvmInnerClassesEntry,uint16_t,&SgAsmJvmInnerClassesEntry::p_outer_class_info_index> {
36619 using field_type = uint16_t;
36620 static constexpr size_t position{1};
36621 static constexpr char const * const name{"outer_class_info_index"};
36622 static constexpr char const * const typestr{"uint16_t"};
36623 static constexpr bool traverse{false};
36624 static constexpr auto mbr_ptr{&SgAsmJvmInnerClassesEntry::p_outer_class_info_index};
36625 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36626 using bind = Desc<SgAsmJvmInnerClassesEntry, uint16_t SgAsmJvmInnerClassesEntry::*, &SgAsmJvmInnerClassesEntry::p_outer_class_info_index>;
36627};
36628template <> struct describe_field_t<SgAsmJvmInnerClassesEntry,uint16_t,&SgAsmJvmInnerClassesEntry::p_inner_name_index> {
36630 using field_type = uint16_t;
36631 static constexpr size_t position{2};
36632 static constexpr char const * const name{"inner_name_index"};
36633 static constexpr char const * const typestr{"uint16_t"};
36634 static constexpr bool traverse{false};
36635 static constexpr auto mbr_ptr{&SgAsmJvmInnerClassesEntry::p_inner_name_index};
36636 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36637 using bind = Desc<SgAsmJvmInnerClassesEntry, uint16_t SgAsmJvmInnerClassesEntry::*, &SgAsmJvmInnerClassesEntry::p_inner_name_index>;
36638};
36639template <> struct describe_field_t<SgAsmJvmInnerClassesEntry,uint16_t,&SgAsmJvmInnerClassesEntry::p_inner_class_access_flags> {
36641 using field_type = uint16_t;
36642 static constexpr size_t position{3};
36643 static constexpr char const * const name{"inner_class_access_flags"};
36644 static constexpr char const * const typestr{"uint16_t"};
36645 static constexpr bool traverse{false};
36646 static constexpr auto mbr_ptr{&SgAsmJvmInnerClassesEntry::p_inner_class_access_flags};
36647 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36648 using bind = Desc<SgAsmJvmInnerClassesEntry, uint16_t SgAsmJvmInnerClassesEntry::*, &SgAsmJvmInnerClassesEntry::p_inner_class_access_flags>;
36649};
36659template <> struct node_from_variant_t<943> { using type = SgAsmJvmInnerClassesEntry; };
36660
36661// Class: AsmJvmInnerClasses
36662template <> struct describe_field_t<SgAsmJvmInnerClasses,SgAsmJvmInnerClassesEntryPtrList,&SgAsmJvmInnerClasses::p_classes> {
36664 using field_type = SgAsmJvmInnerClassesEntryPtrList;
36665 static constexpr size_t position{0};
36666 static constexpr char const * const name{"classes"};
36667 static constexpr char const * const typestr{"SgAsmJvmInnerClassesEntryPtrList"};
36668 static constexpr bool traverse{false};
36669 static constexpr auto mbr_ptr{&SgAsmJvmInnerClasses::p_classes};
36670 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36671 using bind = Desc<SgAsmJvmInnerClasses, SgAsmJvmInnerClassesEntryPtrList SgAsmJvmInnerClasses::*, &SgAsmJvmInnerClasses::p_classes>;
36672};
36674 using node = SgAsmJvmInnerClasses;
36675 using base = SgAsmJvmAttribute;
36676 static constexpr char const * const name{"AsmJvmInnerClasses"};
36677 static constexpr unsigned long variant{944};
36678 static constexpr bool concrete{true};
36679 using subclasses_t = mp::List<>;
36681};
36682template <> struct node_from_variant_t<944> { using type = SgAsmJvmInnerClasses; };
36683
36684// Class: AsmCilInstruction
36685template <> struct describe_field_t<SgAsmCilInstruction,Rose::BinaryAnalysis::CilInstructionKind,&SgAsmCilInstruction::p_kind> {
36687 using field_type = Rose::BinaryAnalysis::CilInstructionKind;
36688 static constexpr size_t position{0};
36689 static constexpr char const * const name{"kind"};
36690 static constexpr char const * const typestr{"Rose::BinaryAnalysis::CilInstructionKind"};
36691 static constexpr bool traverse{false};
36692 static constexpr auto mbr_ptr{&SgAsmCilInstruction::p_kind};
36693 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36694 using bind = Desc<SgAsmCilInstruction, Rose::BinaryAnalysis::CilInstructionKind SgAsmCilInstruction::*, &SgAsmCilInstruction::p_kind>;
36695};
36697 using node = SgAsmCilInstruction;
36698 using base = SgAsmInstruction;
36699 static constexpr char const * const name{"AsmCilInstruction"};
36700 static constexpr unsigned long variant{945};
36701 static constexpr bool concrete{true};
36702 using subclasses_t = mp::List<>;
36704};
36705template <> struct node_from_variant_t<945> { using type = SgAsmCilInstruction; };
36706
36707// Class: AsmStackExpression
36708template <> struct describe_field_t<SgAsmStackExpression,int,&SgAsmStackExpression::p_stackPosition> {
36710 using field_type = int;
36711 static constexpr size_t position{0};
36712 static constexpr char const * const name{"stackPosition"};
36713 static constexpr char const * const typestr{"int"};
36714 static constexpr bool traverse{false};
36715 static constexpr auto mbr_ptr{&SgAsmStackExpression::p_stackPosition};
36716 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36717 using bind = Desc<SgAsmStackExpression, int SgAsmStackExpression::*, &SgAsmStackExpression::p_stackPosition>;
36718};
36720 using node = SgAsmStackExpression;
36721 using base = SgAsmExpression;
36722 static constexpr char const * const name{"AsmStackExpression"};
36723 static constexpr unsigned long variant{946};
36724 static constexpr bool concrete{true};
36725 using subclasses_t = mp::List<>;
36727};
36728template <> struct node_from_variant_t<946> { using type = SgAsmStackExpression; };
36729
36730// Class: AsmJvmEnclosingMethod
36731template <> struct describe_field_t<SgAsmJvmEnclosingMethod,uint16_t,&SgAsmJvmEnclosingMethod::p_class_index> {
36733 using field_type = uint16_t;
36734 static constexpr size_t position{0};
36735 static constexpr char const * const name{"class_index"};
36736 static constexpr char const * const typestr{"uint16_t"};
36737 static constexpr bool traverse{false};
36738 static constexpr auto mbr_ptr{&SgAsmJvmEnclosingMethod::p_class_index};
36739 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36740 using bind = Desc<SgAsmJvmEnclosingMethod, uint16_t SgAsmJvmEnclosingMethod::*, &SgAsmJvmEnclosingMethod::p_class_index>;
36741};
36742template <> struct describe_field_t<SgAsmJvmEnclosingMethod,uint16_t,&SgAsmJvmEnclosingMethod::p_method_index> {
36744 using field_type = uint16_t;
36745 static constexpr size_t position{1};
36746 static constexpr char const * const name{"method_index"};
36747 static constexpr char const * const typestr{"uint16_t"};
36748 static constexpr bool traverse{false};
36749 static constexpr auto mbr_ptr{&SgAsmJvmEnclosingMethod::p_method_index};
36750 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36751 using bind = Desc<SgAsmJvmEnclosingMethod, uint16_t SgAsmJvmEnclosingMethod::*, &SgAsmJvmEnclosingMethod::p_method_index>;
36752};
36755 using base = SgAsmJvmAttribute;
36756 static constexpr char const * const name{"AsmJvmEnclosingMethod"};
36757 static constexpr unsigned long variant{947};
36758 static constexpr bool concrete{true};
36759 using subclasses_t = mp::List<>;
36761};
36762template <> struct node_from_variant_t<947> { using type = SgAsmJvmEnclosingMethod; };
36763
36764// Class: AdaNullConstraint
36766 using node = SgAdaNullConstraint;
36767 using base = SgAdaTypeConstraint;
36768 static constexpr char const * const name{"AdaNullConstraint"};
36769 static constexpr unsigned long variant{948};
36770 static constexpr bool concrete{true};
36771 using subclasses_t = mp::List<>;
36772 using fields_t = mp::List<>;
36773};
36774template <> struct node_from_variant_t<948> { using type = SgAdaNullConstraint; };
36775
36776// Class: AsmJvmModuleMainClass
36777template <> struct describe_field_t<SgAsmJvmModuleMainClass,uint16_t,&SgAsmJvmModuleMainClass::p_main_class_index> {
36779 using field_type = uint16_t;
36780 static constexpr size_t position{0};
36781 static constexpr char const * const name{"main_class_index"};
36782 static constexpr char const * const typestr{"uint16_t"};
36783 static constexpr bool traverse{false};
36784 static constexpr auto mbr_ptr{&SgAsmJvmModuleMainClass::p_main_class_index};
36785 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36786 using bind = Desc<SgAsmJvmModuleMainClass, uint16_t SgAsmJvmModuleMainClass::*, &SgAsmJvmModuleMainClass::p_main_class_index>;
36787};
36790 using base = SgAsmJvmAttribute;
36791 static constexpr char const * const name{"AsmJvmModuleMainClass"};
36792 static constexpr unsigned long variant{949};
36793 static constexpr bool concrete{true};
36794 using subclasses_t = mp::List<>;
36796};
36797template <> struct node_from_variant_t<949> { using type = SgAsmJvmModuleMainClass; };
36798
36799// Class: AsmInstructionList
36800template <> struct describe_field_t<SgAsmInstructionList,SgAsmInstructionPtrList,&SgAsmInstructionList::p_instructions> {
36802 using field_type = SgAsmInstructionPtrList;
36803 static constexpr size_t position{0};
36804 static constexpr char const * const name{"instructions"};
36805 static constexpr char const * const typestr{"SgAsmInstructionPtrList"};
36806 static constexpr bool traverse{false};
36807 static constexpr auto mbr_ptr{&SgAsmInstructionList::p_instructions};
36808 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36809 using bind = Desc<SgAsmInstructionList, SgAsmInstructionPtrList SgAsmInstructionList::*, &SgAsmInstructionList::p_instructions>;
36810};
36812 using node = SgAsmInstructionList;
36813 using base = SgAsmNode;
36814 static constexpr char const * const name{"AsmInstructionList"};
36815 static constexpr unsigned long variant{950};
36816 static constexpr bool concrete{true};
36817 using subclasses_t = mp::List<>;
36819};
36820template <> struct node_from_variant_t<950> { using type = SgAsmInstructionList; };
36821
36822// Class: AsmCilNode
36823template <> struct describe_node_t<SgAsmCilNode> {
36824 using node = SgAsmCilNode;
36825 using base = SgAsmNode;
36826 static constexpr char const * const name{"AsmCilNode"};
36827 static constexpr unsigned long variant{951};
36828 static constexpr bool concrete{false};
36830 using fields_t = mp::List<>;
36831};
36832template <> struct node_from_variant_t<951> { using type = SgAsmCilNode; };
36833
36834// Class: AsmCilAssembly
36835template <> struct describe_field_t<SgAsmCilAssembly,uint32_t,&SgAsmCilAssembly::p_HashAlgId> {
36836 using parent = SgAsmCilAssembly;
36837 using field_type = uint32_t;
36838 static constexpr size_t position{0};
36839 static constexpr char const * const name{"HashAlgId"};
36840 static constexpr char const * const typestr{"uint32_t"};
36841 static constexpr bool traverse{false};
36842 static constexpr auto mbr_ptr{&SgAsmCilAssembly::p_HashAlgId};
36843 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36844 using bind = Desc<SgAsmCilAssembly, uint32_t SgAsmCilAssembly::*, &SgAsmCilAssembly::p_HashAlgId>;
36845};
36846template <> struct describe_field_t<SgAsmCilAssembly,uint16_t,&SgAsmCilAssembly::p_MajorVersion> {
36847 using parent = SgAsmCilAssembly;
36848 using field_type = uint16_t;
36849 static constexpr size_t position{1};
36850 static constexpr char const * const name{"MajorVersion"};
36851 static constexpr char const * const typestr{"uint16_t"};
36852 static constexpr bool traverse{false};
36853 static constexpr auto mbr_ptr{&SgAsmCilAssembly::p_MajorVersion};
36854 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36855 using bind = Desc<SgAsmCilAssembly, uint16_t SgAsmCilAssembly::*, &SgAsmCilAssembly::p_MajorVersion>;
36856};
36857template <> struct describe_field_t<SgAsmCilAssembly,uint16_t,&SgAsmCilAssembly::p_MinorVersion> {
36858 using parent = SgAsmCilAssembly;
36859 using field_type = uint16_t;
36860 static constexpr size_t position{2};
36861 static constexpr char const * const name{"MinorVersion"};
36862 static constexpr char const * const typestr{"uint16_t"};
36863 static constexpr bool traverse{false};
36864 static constexpr auto mbr_ptr{&SgAsmCilAssembly::p_MinorVersion};
36865 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36866 using bind = Desc<SgAsmCilAssembly, uint16_t SgAsmCilAssembly::*, &SgAsmCilAssembly::p_MinorVersion>;
36867};
36868template <> struct describe_field_t<SgAsmCilAssembly,uint16_t,&SgAsmCilAssembly::p_BuildNumber> {
36869 using parent = SgAsmCilAssembly;
36870 using field_type = uint16_t;
36871 static constexpr size_t position{3};
36872 static constexpr char const * const name{"BuildNumber"};
36873 static constexpr char const * const typestr{"uint16_t"};
36874 static constexpr bool traverse{false};
36875 static constexpr auto mbr_ptr{&SgAsmCilAssembly::p_BuildNumber};
36876 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36877 using bind = Desc<SgAsmCilAssembly, uint16_t SgAsmCilAssembly::*, &SgAsmCilAssembly::p_BuildNumber>;
36878};
36879template <> struct describe_field_t<SgAsmCilAssembly,uint16_t,&SgAsmCilAssembly::p_RevisionNumber> {
36880 using parent = SgAsmCilAssembly;
36881 using field_type = uint16_t;
36882 static constexpr size_t position{4};
36883 static constexpr char const * const name{"RevisionNumber"};
36884 static constexpr char const * const typestr{"uint16_t"};
36885 static constexpr bool traverse{false};
36886 static constexpr auto mbr_ptr{&SgAsmCilAssembly::p_RevisionNumber};
36887 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36888 using bind = Desc<SgAsmCilAssembly, uint16_t SgAsmCilAssembly::*, &SgAsmCilAssembly::p_RevisionNumber>;
36889};
36890template <> struct describe_field_t<SgAsmCilAssembly,uint32_t,&SgAsmCilAssembly::p_Flags> {
36891 using parent = SgAsmCilAssembly;
36892 using field_type = uint32_t;
36893 static constexpr size_t position{5};
36894 static constexpr char const * const name{"Flags"};
36895 static constexpr char const * const typestr{"uint32_t"};
36896 static constexpr bool traverse{false};
36897 static constexpr auto mbr_ptr{&SgAsmCilAssembly::p_Flags};
36898 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36899 using bind = Desc<SgAsmCilAssembly, uint32_t SgAsmCilAssembly::*, &SgAsmCilAssembly::p_Flags>;
36900};
36901template <> struct describe_field_t<SgAsmCilAssembly,uint32_t,&SgAsmCilAssembly::p_PublicKey> {
36902 using parent = SgAsmCilAssembly;
36903 using field_type = uint32_t;
36904 static constexpr size_t position{6};
36905 static constexpr char const * const name{"PublicKey"};
36906 static constexpr char const * const typestr{"uint32_t"};
36907 static constexpr bool traverse{false};
36908 static constexpr auto mbr_ptr{&SgAsmCilAssembly::p_PublicKey};
36909 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36910 using bind = Desc<SgAsmCilAssembly, uint32_t SgAsmCilAssembly::*, &SgAsmCilAssembly::p_PublicKey>;
36911};
36912template <> struct describe_field_t<SgAsmCilAssembly,uint32_t,&SgAsmCilAssembly::p_Name> {
36913 using parent = SgAsmCilAssembly;
36914 using field_type = uint32_t;
36915 static constexpr size_t position{7};
36916 static constexpr char const * const name{"Name"};
36917 static constexpr char const * const typestr{"uint32_t"};
36918 static constexpr bool traverse{false};
36919 static constexpr auto mbr_ptr{&SgAsmCilAssembly::p_Name};
36920 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36921 using bind = Desc<SgAsmCilAssembly, uint32_t SgAsmCilAssembly::*, &SgAsmCilAssembly::p_Name>;
36922};
36923template <> struct describe_field_t<SgAsmCilAssembly,uint32_t,&SgAsmCilAssembly::p_Culture> {
36924 using parent = SgAsmCilAssembly;
36925 using field_type = uint32_t;
36926 static constexpr size_t position{8};
36927 static constexpr char const * const name{"Culture"};
36928 static constexpr char const * const typestr{"uint32_t"};
36929 static constexpr bool traverse{false};
36930 static constexpr auto mbr_ptr{&SgAsmCilAssembly::p_Culture};
36931 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36932 using bind = Desc<SgAsmCilAssembly, uint32_t SgAsmCilAssembly::*, &SgAsmCilAssembly::p_Culture>;
36933};
36943template <> struct node_from_variant_t<952> { using type = SgAsmCilAssembly; };
36944
36945// Class: AsmCilAssemblyOS
36946template <> struct describe_field_t<SgAsmCilAssemblyOS,uint32_t,&SgAsmCilAssemblyOS::p_OSPlatformID> {
36947 using parent = SgAsmCilAssemblyOS;
36948 using field_type = uint32_t;
36949 static constexpr size_t position{0};
36950 static constexpr char const * const name{"OSPlatformID"};
36951 static constexpr char const * const typestr{"uint32_t"};
36952 static constexpr bool traverse{false};
36953 static constexpr auto mbr_ptr{&SgAsmCilAssemblyOS::p_OSPlatformID};
36954 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36955 using bind = Desc<SgAsmCilAssemblyOS, uint32_t SgAsmCilAssemblyOS::*, &SgAsmCilAssemblyOS::p_OSPlatformID>;
36956};
36957template <> struct describe_field_t<SgAsmCilAssemblyOS,uint32_t,&SgAsmCilAssemblyOS::p_OSMajorVersion> {
36958 using parent = SgAsmCilAssemblyOS;
36959 using field_type = uint32_t;
36960 static constexpr size_t position{1};
36961 static constexpr char const * const name{"OSMajorVersion"};
36962 static constexpr char const * const typestr{"uint32_t"};
36963 static constexpr bool traverse{false};
36964 static constexpr auto mbr_ptr{&SgAsmCilAssemblyOS::p_OSMajorVersion};
36965 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36966 using bind = Desc<SgAsmCilAssemblyOS, uint32_t SgAsmCilAssemblyOS::*, &SgAsmCilAssemblyOS::p_OSMajorVersion>;
36967};
36968template <> struct describe_field_t<SgAsmCilAssemblyOS,uint32_t,&SgAsmCilAssemblyOS::p_OSMinorVersion> {
36969 using parent = SgAsmCilAssemblyOS;
36970 using field_type = uint32_t;
36971 static constexpr size_t position{2};
36972 static constexpr char const * const name{"OSMinorVersion"};
36973 static constexpr char const * const typestr{"uint32_t"};
36974 static constexpr bool traverse{false};
36975 static constexpr auto mbr_ptr{&SgAsmCilAssemblyOS::p_OSMinorVersion};
36976 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
36977 using bind = Desc<SgAsmCilAssemblyOS, uint32_t SgAsmCilAssemblyOS::*, &SgAsmCilAssemblyOS::p_OSMinorVersion>;
36978};
36980 using node = SgAsmCilAssemblyOS;
36981 using base = SgAsmCilMetadata;
36982 static constexpr char const * const name{"AsmCilAssemblyOS"};
36983 static constexpr unsigned long variant{953};
36984 static constexpr bool concrete{true};
36985 using subclasses_t = mp::List<>;
36987};
36988template <> struct node_from_variant_t<953> { using type = SgAsmCilAssemblyOS; };
36989
36990// Class: AsmCilAssemblyProcessor
36991template <> struct describe_field_t<SgAsmCilAssemblyProcessor,uint32_t,&SgAsmCilAssemblyProcessor::p_Processor> {
36993 using field_type = uint32_t;
36994 static constexpr size_t position{0};
36995 static constexpr char const * const name{"Processor"};
36996 static constexpr char const * const typestr{"uint32_t"};
36997 static constexpr bool traverse{false};
36998 static constexpr auto mbr_ptr{&SgAsmCilAssemblyProcessor::p_Processor};
36999 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37000 using bind = Desc<SgAsmCilAssemblyProcessor, uint32_t SgAsmCilAssemblyProcessor::*, &SgAsmCilAssemblyProcessor::p_Processor>;
37001};
37004 using base = SgAsmCilMetadata;
37005 static constexpr char const * const name{"AsmCilAssemblyProcessor"};
37006 static constexpr unsigned long variant{954};
37007 static constexpr bool concrete{true};
37008 using subclasses_t = mp::List<>;
37010};
37011template <> struct node_from_variant_t<954> { using type = SgAsmCilAssemblyProcessor; };
37012
37013// Class: AsmCilAssemblyRef
37014template <> struct describe_field_t<SgAsmCilAssemblyRef,uint16_t,&SgAsmCilAssemblyRef::p_MajorVersion> {
37016 using field_type = uint16_t;
37017 static constexpr size_t position{0};
37018 static constexpr char const * const name{"MajorVersion"};
37019 static constexpr char const * const typestr{"uint16_t"};
37020 static constexpr bool traverse{false};
37021 static constexpr auto mbr_ptr{&SgAsmCilAssemblyRef::p_MajorVersion};
37022 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37023 using bind = Desc<SgAsmCilAssemblyRef, uint16_t SgAsmCilAssemblyRef::*, &SgAsmCilAssemblyRef::p_MajorVersion>;
37024};
37025template <> struct describe_field_t<SgAsmCilAssemblyRef,uint16_t,&SgAsmCilAssemblyRef::p_MinorVersion> {
37027 using field_type = uint16_t;
37028 static constexpr size_t position{1};
37029 static constexpr char const * const name{"MinorVersion"};
37030 static constexpr char const * const typestr{"uint16_t"};
37031 static constexpr bool traverse{false};
37032 static constexpr auto mbr_ptr{&SgAsmCilAssemblyRef::p_MinorVersion};
37033 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37034 using bind = Desc<SgAsmCilAssemblyRef, uint16_t SgAsmCilAssemblyRef::*, &SgAsmCilAssemblyRef::p_MinorVersion>;
37035};
37036template <> struct describe_field_t<SgAsmCilAssemblyRef,uint16_t,&SgAsmCilAssemblyRef::p_BuildNumber> {
37038 using field_type = uint16_t;
37039 static constexpr size_t position{2};
37040 static constexpr char const * const name{"BuildNumber"};
37041 static constexpr char const * const typestr{"uint16_t"};
37042 static constexpr bool traverse{false};
37043 static constexpr auto mbr_ptr{&SgAsmCilAssemblyRef::p_BuildNumber};
37044 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37045 using bind = Desc<SgAsmCilAssemblyRef, uint16_t SgAsmCilAssemblyRef::*, &SgAsmCilAssemblyRef::p_BuildNumber>;
37046};
37047template <> struct describe_field_t<SgAsmCilAssemblyRef,uint16_t,&SgAsmCilAssemblyRef::p_RevisionNumber> {
37049 using field_type = uint16_t;
37050 static constexpr size_t position{3};
37051 static constexpr char const * const name{"RevisionNumber"};
37052 static constexpr char const * const typestr{"uint16_t"};
37053 static constexpr bool traverse{false};
37054 static constexpr auto mbr_ptr{&SgAsmCilAssemblyRef::p_RevisionNumber};
37055 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37056 using bind = Desc<SgAsmCilAssemblyRef, uint16_t SgAsmCilAssemblyRef::*, &SgAsmCilAssemblyRef::p_RevisionNumber>;
37057};
37058template <> struct describe_field_t<SgAsmCilAssemblyRef,uint32_t,&SgAsmCilAssemblyRef::p_Flags> {
37060 using field_type = uint32_t;
37061 static constexpr size_t position{4};
37062 static constexpr char const * const name{"Flags"};
37063 static constexpr char const * const typestr{"uint32_t"};
37064 static constexpr bool traverse{false};
37065 static constexpr auto mbr_ptr{&SgAsmCilAssemblyRef::p_Flags};
37066 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37067 using bind = Desc<SgAsmCilAssemblyRef, uint32_t SgAsmCilAssemblyRef::*, &SgAsmCilAssemblyRef::p_Flags>;
37068};
37069template <> struct describe_field_t<SgAsmCilAssemblyRef,uint32_t,&SgAsmCilAssemblyRef::p_PublicKeyOrToken> {
37071 using field_type = uint32_t;
37072 static constexpr size_t position{5};
37073 static constexpr char const * const name{"PublicKeyOrToken"};
37074 static constexpr char const * const typestr{"uint32_t"};
37075 static constexpr bool traverse{false};
37076 static constexpr auto mbr_ptr{&SgAsmCilAssemblyRef::p_PublicKeyOrToken};
37077 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37078 using bind = Desc<SgAsmCilAssemblyRef, uint32_t SgAsmCilAssemblyRef::*, &SgAsmCilAssemblyRef::p_PublicKeyOrToken>;
37079};
37080template <> struct describe_field_t<SgAsmCilAssemblyRef,uint32_t,&SgAsmCilAssemblyRef::p_Name> {
37082 using field_type = uint32_t;
37083 static constexpr size_t position{6};
37084 static constexpr char const * const name{"Name"};
37085 static constexpr char const * const typestr{"uint32_t"};
37086 static constexpr bool traverse{false};
37087 static constexpr auto mbr_ptr{&SgAsmCilAssemblyRef::p_Name};
37088 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37089 using bind = Desc<SgAsmCilAssemblyRef, uint32_t SgAsmCilAssemblyRef::*, &SgAsmCilAssemblyRef::p_Name>;
37090};
37091template <> struct describe_field_t<SgAsmCilAssemblyRef,uint32_t,&SgAsmCilAssemblyRef::p_Culture> {
37093 using field_type = uint32_t;
37094 static constexpr size_t position{7};
37095 static constexpr char const * const name{"Culture"};
37096 static constexpr char const * const typestr{"uint32_t"};
37097 static constexpr bool traverse{false};
37098 static constexpr auto mbr_ptr{&SgAsmCilAssemblyRef::p_Culture};
37099 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37100 using bind = Desc<SgAsmCilAssemblyRef, uint32_t SgAsmCilAssemblyRef::*, &SgAsmCilAssemblyRef::p_Culture>;
37101};
37102template <> struct describe_field_t<SgAsmCilAssemblyRef,uint32_t,&SgAsmCilAssemblyRef::p_HashValue> {
37104 using field_type = uint32_t;
37105 static constexpr size_t position{8};
37106 static constexpr char const * const name{"HashValue"};
37107 static constexpr char const * const typestr{"uint32_t"};
37108 static constexpr bool traverse{false};
37109 static constexpr auto mbr_ptr{&SgAsmCilAssemblyRef::p_HashValue};
37110 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37111 using bind = Desc<SgAsmCilAssemblyRef, uint32_t SgAsmCilAssemblyRef::*, &SgAsmCilAssemblyRef::p_HashValue>;
37112};
37122template <> struct node_from_variant_t<955> { using type = SgAsmCilAssemblyRef; };
37123
37124// Class: AsmCilAssemblyRefOS
37125template <> struct describe_field_t<SgAsmCilAssemblyRefOS,uint32_t,&SgAsmCilAssemblyRefOS::p_OSPlatformID> {
37127 using field_type = uint32_t;
37128 static constexpr size_t position{0};
37129 static constexpr char const * const name{"OSPlatformID"};
37130 static constexpr char const * const typestr{"uint32_t"};
37131 static constexpr bool traverse{false};
37132 static constexpr auto mbr_ptr{&SgAsmCilAssemblyRefOS::p_OSPlatformID};
37133 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37134 using bind = Desc<SgAsmCilAssemblyRefOS, uint32_t SgAsmCilAssemblyRefOS::*, &SgAsmCilAssemblyRefOS::p_OSPlatformID>;
37135};
37136template <> struct describe_field_t<SgAsmCilAssemblyRefOS,uint32_t,&SgAsmCilAssemblyRefOS::p_OSMajorVersion> {
37138 using field_type = uint32_t;
37139 static constexpr size_t position{1};
37140 static constexpr char const * const name{"OSMajorVersion"};
37141 static constexpr char const * const typestr{"uint32_t"};
37142 static constexpr bool traverse{false};
37143 static constexpr auto mbr_ptr{&SgAsmCilAssemblyRefOS::p_OSMajorVersion};
37144 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37145 using bind = Desc<SgAsmCilAssemblyRefOS, uint32_t SgAsmCilAssemblyRefOS::*, &SgAsmCilAssemblyRefOS::p_OSMajorVersion>;
37146};
37147template <> struct describe_field_t<SgAsmCilAssemblyRefOS,uint32_t,&SgAsmCilAssemblyRefOS::p_OSMinorVersion> {
37149 using field_type = uint32_t;
37150 static constexpr size_t position{2};
37151 static constexpr char const * const name{"OSMinorVersion"};
37152 static constexpr char const * const typestr{"uint32_t"};
37153 static constexpr bool traverse{false};
37154 static constexpr auto mbr_ptr{&SgAsmCilAssemblyRefOS::p_OSMinorVersion};
37155 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37156 using bind = Desc<SgAsmCilAssemblyRefOS, uint32_t SgAsmCilAssemblyRefOS::*, &SgAsmCilAssemblyRefOS::p_OSMinorVersion>;
37157};
37158template <> struct describe_field_t<SgAsmCilAssemblyRefOS,uint32_t,&SgAsmCilAssemblyRefOS::p_AssemblyRefOS> {
37160 using field_type = uint32_t;
37161 static constexpr size_t position{3};
37162 static constexpr char const * const name{"AssemblyRefOS"};
37163 static constexpr char const * const typestr{"uint32_t"};
37164 static constexpr bool traverse{false};
37165 static constexpr auto mbr_ptr{&SgAsmCilAssemblyRefOS::p_AssemblyRefOS};
37166 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37167 using bind = Desc<SgAsmCilAssemblyRefOS, uint32_t SgAsmCilAssemblyRefOS::*, &SgAsmCilAssemblyRefOS::p_AssemblyRefOS>;
37168};
37178template <> struct node_from_variant_t<956> { using type = SgAsmCilAssemblyRefOS; };
37179
37180// Class: AsmCilAssemblyRefProcessor
37181template <> struct describe_field_t<SgAsmCilAssemblyRefProcessor,uint32_t,&SgAsmCilAssemblyRefProcessor::p_Processor> {
37183 using field_type = uint32_t;
37184 static constexpr size_t position{0};
37185 static constexpr char const * const name{"Processor"};
37186 static constexpr char const * const typestr{"uint32_t"};
37187 static constexpr bool traverse{false};
37188 static constexpr auto mbr_ptr{&SgAsmCilAssemblyRefProcessor::p_Processor};
37189 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37190 using bind = Desc<SgAsmCilAssemblyRefProcessor, uint32_t SgAsmCilAssemblyRefProcessor::*, &SgAsmCilAssemblyRefProcessor::p_Processor>;
37191};
37192template <> struct describe_field_t<SgAsmCilAssemblyRefProcessor,uint32_t,&SgAsmCilAssemblyRefProcessor::p_AssemblyRef> {
37194 using field_type = uint32_t;
37195 static constexpr size_t position{1};
37196 static constexpr char const * const name{"AssemblyRef"};
37197 static constexpr char const * const typestr{"uint32_t"};
37198 static constexpr bool traverse{false};
37199 static constexpr auto mbr_ptr{&SgAsmCilAssemblyRefProcessor::p_AssemblyRef};
37200 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37201 using bind = Desc<SgAsmCilAssemblyRefProcessor, uint32_t SgAsmCilAssemblyRefProcessor::*, &SgAsmCilAssemblyRefProcessor::p_AssemblyRef>;
37202};
37205 using base = SgAsmCilMetadata;
37206 static constexpr char const * const name{"AsmCilAssemblyRefProcessor"};
37207 static constexpr unsigned long variant{957};
37208 static constexpr bool concrete{true};
37209 using subclasses_t = mp::List<>;
37211};
37212template <> struct node_from_variant_t<957> { using type = SgAsmCilAssemblyRefProcessor; };
37213
37214// Class: AsmCilClassLayout
37215template <> struct describe_field_t<SgAsmCilClassLayout,uint16_t,&SgAsmCilClassLayout::p_PackingSize> {
37217 using field_type = uint16_t;
37218 static constexpr size_t position{0};
37219 static constexpr char const * const name{"PackingSize"};
37220 static constexpr char const * const typestr{"uint16_t"};
37221 static constexpr bool traverse{false};
37222 static constexpr auto mbr_ptr{&SgAsmCilClassLayout::p_PackingSize};
37223 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37224 using bind = Desc<SgAsmCilClassLayout, uint16_t SgAsmCilClassLayout::*, &SgAsmCilClassLayout::p_PackingSize>;
37225};
37226template <> struct describe_field_t<SgAsmCilClassLayout,uint32_t,&SgAsmCilClassLayout::p_ClassSize> {
37228 using field_type = uint32_t;
37229 static constexpr size_t position{1};
37230 static constexpr char const * const name{"ClassSize"};
37231 static constexpr char const * const typestr{"uint32_t"};
37232 static constexpr bool traverse{false};
37233 static constexpr auto mbr_ptr{&SgAsmCilClassLayout::p_ClassSize};
37234 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37235 using bind = Desc<SgAsmCilClassLayout, uint32_t SgAsmCilClassLayout::*, &SgAsmCilClassLayout::p_ClassSize>;
37236};
37237template <> struct describe_field_t<SgAsmCilClassLayout,uint32_t,&SgAsmCilClassLayout::p_Parent> {
37239 using field_type = uint32_t;
37240 static constexpr size_t position{2};
37241 static constexpr char const * const name{"Parent"};
37242 static constexpr char const * const typestr{"uint32_t"};
37243 static constexpr bool traverse{false};
37244 static constexpr auto mbr_ptr{&SgAsmCilClassLayout::p_Parent};
37245 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37246 using bind = Desc<SgAsmCilClassLayout, uint32_t SgAsmCilClassLayout::*, &SgAsmCilClassLayout::p_Parent>;
37247};
37249 using node = SgAsmCilClassLayout;
37250 using base = SgAsmCilMetadata;
37251 static constexpr char const * const name{"AsmCilClassLayout"};
37252 static constexpr unsigned long variant{958};
37253 static constexpr bool concrete{true};
37254 using subclasses_t = mp::List<>;
37256};
37257template <> struct node_from_variant_t<958> { using type = SgAsmCilClassLayout; };
37258
37259// Class: AsmCilConstant
37260template <> struct describe_field_t<SgAsmCilConstant,uint8_t,&SgAsmCilConstant::p_Type> {
37261 using parent = SgAsmCilConstant;
37262 using field_type = uint8_t;
37263 static constexpr size_t position{0};
37264 static constexpr char const * const name{"Type"};
37265 static constexpr char const * const typestr{"uint8_t"};
37266 static constexpr bool traverse{false};
37267 static constexpr auto mbr_ptr{&SgAsmCilConstant::p_Type};
37268 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37269 using bind = Desc<SgAsmCilConstant, uint8_t SgAsmCilConstant::*, &SgAsmCilConstant::p_Type>;
37270};
37271template <> struct describe_field_t<SgAsmCilConstant,uint8_t,&SgAsmCilConstant::p_Padding> {
37272 using parent = SgAsmCilConstant;
37273 using field_type = uint8_t;
37274 static constexpr size_t position{1};
37275 static constexpr char const * const name{"Padding"};
37276 static constexpr char const * const typestr{"uint8_t"};
37277 static constexpr bool traverse{false};
37278 static constexpr auto mbr_ptr{&SgAsmCilConstant::p_Padding};
37279 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37280 using bind = Desc<SgAsmCilConstant, uint8_t SgAsmCilConstant::*, &SgAsmCilConstant::p_Padding>;
37281};
37282template <> struct describe_field_t<SgAsmCilConstant,uint32_t,&SgAsmCilConstant::p_Parent> {
37283 using parent = SgAsmCilConstant;
37284 using field_type = uint32_t;
37285 static constexpr size_t position{2};
37286 static constexpr char const * const name{"Parent"};
37287 static constexpr char const * const typestr{"uint32_t"};
37288 static constexpr bool traverse{false};
37289 static constexpr auto mbr_ptr{&SgAsmCilConstant::p_Parent};
37290 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37291 using bind = Desc<SgAsmCilConstant, uint32_t SgAsmCilConstant::*, &SgAsmCilConstant::p_Parent>;
37292};
37293template <> struct describe_field_t<SgAsmCilConstant,uint32_t,&SgAsmCilConstant::p_Value> {
37294 using parent = SgAsmCilConstant;
37295 using field_type = uint32_t;
37296 static constexpr size_t position{3};
37297 static constexpr char const * const name{"Value"};
37298 static constexpr char const * const typestr{"uint32_t"};
37299 static constexpr bool traverse{false};
37300 static constexpr auto mbr_ptr{&SgAsmCilConstant::p_Value};
37301 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37302 using bind = Desc<SgAsmCilConstant, uint32_t SgAsmCilConstant::*, &SgAsmCilConstant::p_Value>;
37303};
37305 using node = SgAsmCilConstant;
37306 using base = SgAsmCilMetadata;
37307 static constexpr char const * const name{"AsmCilConstant"};
37308 static constexpr unsigned long variant{959};
37309 static constexpr bool concrete{true};
37310 using subclasses_t = mp::List<>;
37312};
37313template <> struct node_from_variant_t<959> { using type = SgAsmCilConstant; };
37314
37315// Class: AsmCilCustomAttribute
37316template <> struct describe_field_t<SgAsmCilCustomAttribute,uint32_t,&SgAsmCilCustomAttribute::p_Parent> {
37318 using field_type = uint32_t;
37319 static constexpr size_t position{0};
37320 static constexpr char const * const name{"Parent"};
37321 static constexpr char const * const typestr{"uint32_t"};
37322 static constexpr bool traverse{false};
37323 static constexpr auto mbr_ptr{&SgAsmCilCustomAttribute::p_Parent};
37324 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37325 using bind = Desc<SgAsmCilCustomAttribute, uint32_t SgAsmCilCustomAttribute::*, &SgAsmCilCustomAttribute::p_Parent>;
37326};
37327template <> struct describe_field_t<SgAsmCilCustomAttribute,uint32_t,&SgAsmCilCustomAttribute::p_Type> {
37329 using field_type = uint32_t;
37330 static constexpr size_t position{1};
37331 static constexpr char const * const name{"Type"};
37332 static constexpr char const * const typestr{"uint32_t"};
37333 static constexpr bool traverse{false};
37334 static constexpr auto mbr_ptr{&SgAsmCilCustomAttribute::p_Type};
37335 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37336 using bind = Desc<SgAsmCilCustomAttribute, uint32_t SgAsmCilCustomAttribute::*, &SgAsmCilCustomAttribute::p_Type>;
37337};
37338template <> struct describe_field_t<SgAsmCilCustomAttribute,uint32_t,&SgAsmCilCustomAttribute::p_Value> {
37340 using field_type = uint32_t;
37341 static constexpr size_t position{2};
37342 static constexpr char const * const name{"Value"};
37343 static constexpr char const * const typestr{"uint32_t"};
37344 static constexpr bool traverse{false};
37345 static constexpr auto mbr_ptr{&SgAsmCilCustomAttribute::p_Value};
37346 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37347 using bind = Desc<SgAsmCilCustomAttribute, uint32_t SgAsmCilCustomAttribute::*, &SgAsmCilCustomAttribute::p_Value>;
37348};
37351 using base = SgAsmCilMetadata;
37352 static constexpr char const * const name{"AsmCilCustomAttribute"};
37353 static constexpr unsigned long variant{960};
37354 static constexpr bool concrete{true};
37355 using subclasses_t = mp::List<>;
37357};
37358template <> struct node_from_variant_t<960> { using type = SgAsmCilCustomAttribute; };
37359
37360// Class: AsmCilDeclSecurity
37361template <> struct describe_field_t<SgAsmCilDeclSecurity,uint16_t,&SgAsmCilDeclSecurity::p_Action> {
37363 using field_type = uint16_t;
37364 static constexpr size_t position{0};
37365 static constexpr char const * const name{"Action"};
37366 static constexpr char const * const typestr{"uint16_t"};
37367 static constexpr bool traverse{false};
37368 static constexpr auto mbr_ptr{&SgAsmCilDeclSecurity::p_Action};
37369 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37370 using bind = Desc<SgAsmCilDeclSecurity, uint16_t SgAsmCilDeclSecurity::*, &SgAsmCilDeclSecurity::p_Action>;
37371};
37372template <> struct describe_field_t<SgAsmCilDeclSecurity,uint32_t,&SgAsmCilDeclSecurity::p_Parent> {
37374 using field_type = uint32_t;
37375 static constexpr size_t position{1};
37376 static constexpr char const * const name{"Parent"};
37377 static constexpr char const * const typestr{"uint32_t"};
37378 static constexpr bool traverse{false};
37379 static constexpr auto mbr_ptr{&SgAsmCilDeclSecurity::p_Parent};
37380 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37381 using bind = Desc<SgAsmCilDeclSecurity, uint32_t SgAsmCilDeclSecurity::*, &SgAsmCilDeclSecurity::p_Parent>;
37382};
37383template <> struct describe_field_t<SgAsmCilDeclSecurity,uint32_t,&SgAsmCilDeclSecurity::p_PermissionSet> {
37385 using field_type = uint32_t;
37386 static constexpr size_t position{2};
37387 static constexpr char const * const name{"PermissionSet"};
37388 static constexpr char const * const typestr{"uint32_t"};
37389 static constexpr bool traverse{false};
37390 static constexpr auto mbr_ptr{&SgAsmCilDeclSecurity::p_PermissionSet};
37391 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37392 using bind = Desc<SgAsmCilDeclSecurity, uint32_t SgAsmCilDeclSecurity::*, &SgAsmCilDeclSecurity::p_PermissionSet>;
37393};
37395 using node = SgAsmCilDeclSecurity;
37396 using base = SgAsmCilMetadata;
37397 static constexpr char const * const name{"AsmCilDeclSecurity"};
37398 static constexpr unsigned long variant{961};
37399 static constexpr bool concrete{true};
37400 using subclasses_t = mp::List<>;
37402};
37403template <> struct node_from_variant_t<961> { using type = SgAsmCilDeclSecurity; };
37404
37405// Class: AsmCilEvent
37406template <> struct describe_field_t<SgAsmCilEvent,uint16_t,&SgAsmCilEvent::p_EventFlags> {
37407 using parent = SgAsmCilEvent;
37408 using field_type = uint16_t;
37409 static constexpr size_t position{0};
37410 static constexpr char const * const name{"EventFlags"};
37411 static constexpr char const * const typestr{"uint16_t"};
37412 static constexpr bool traverse{false};
37413 static constexpr auto mbr_ptr{&SgAsmCilEvent::p_EventFlags};
37414 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37415 using bind = Desc<SgAsmCilEvent, uint16_t SgAsmCilEvent::*, &SgAsmCilEvent::p_EventFlags>;
37416};
37417template <> struct describe_field_t<SgAsmCilEvent,uint32_t,&SgAsmCilEvent::p_Name> {
37418 using parent = SgAsmCilEvent;
37419 using field_type = uint32_t;
37420 static constexpr size_t position{1};
37421 static constexpr char const * const name{"Name"};
37422 static constexpr char const * const typestr{"uint32_t"};
37423 static constexpr bool traverse{false};
37424 static constexpr auto mbr_ptr{&SgAsmCilEvent::p_Name};
37425 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37426 using bind = Desc<SgAsmCilEvent, uint32_t SgAsmCilEvent::*, &SgAsmCilEvent::p_Name>;
37427};
37428template <> struct describe_field_t<SgAsmCilEvent,uint32_t,&SgAsmCilEvent::p_EventType> {
37429 using parent = SgAsmCilEvent;
37430 using field_type = uint32_t;
37431 static constexpr size_t position{2};
37432 static constexpr char const * const name{"EventType"};
37433 static constexpr char const * const typestr{"uint32_t"};
37434 static constexpr bool traverse{false};
37435 static constexpr auto mbr_ptr{&SgAsmCilEvent::p_EventType};
37436 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37437 using bind = Desc<SgAsmCilEvent, uint32_t SgAsmCilEvent::*, &SgAsmCilEvent::p_EventType>;
37438};
37439template <> struct describe_node_t<SgAsmCilEvent> {
37440 using node = SgAsmCilEvent;
37441 using base = SgAsmCilMetadata;
37442 static constexpr char const * const name{"AsmCilEvent"};
37443 static constexpr unsigned long variant{962};
37444 static constexpr bool concrete{true};
37445 using subclasses_t = mp::List<>;
37447};
37448template <> struct node_from_variant_t<962> { using type = SgAsmCilEvent; };
37449
37450// Class: AsmCilEventMap
37451template <> struct describe_field_t<SgAsmCilEventMap,uint32_t,&SgAsmCilEventMap::p_Parent> {
37452 using parent = SgAsmCilEventMap;
37453 using field_type = uint32_t;
37454 static constexpr size_t position{0};
37455 static constexpr char const * const name{"Parent"};
37456 static constexpr char const * const typestr{"uint32_t"};
37457 static constexpr bool traverse{false};
37458 static constexpr auto mbr_ptr{&SgAsmCilEventMap::p_Parent};
37459 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37460 using bind = Desc<SgAsmCilEventMap, uint32_t SgAsmCilEventMap::*, &SgAsmCilEventMap::p_Parent>;
37461};
37462template <> struct describe_field_t<SgAsmCilEventMap,uint32_t,&SgAsmCilEventMap::p_EventList> {
37463 using parent = SgAsmCilEventMap;
37464 using field_type = uint32_t;
37465 static constexpr size_t position{1};
37466 static constexpr char const * const name{"EventList"};
37467 static constexpr char const * const typestr{"uint32_t"};
37468 static constexpr bool traverse{false};
37469 static constexpr auto mbr_ptr{&SgAsmCilEventMap::p_EventList};
37470 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37471 using bind = Desc<SgAsmCilEventMap, uint32_t SgAsmCilEventMap::*, &SgAsmCilEventMap::p_EventList>;
37472};
37474 using node = SgAsmCilEventMap;
37475 using base = SgAsmCilMetadata;
37476 static constexpr char const * const name{"AsmCilEventMap"};
37477 static constexpr unsigned long variant{963};
37478 static constexpr bool concrete{true};
37479 using subclasses_t = mp::List<>;
37481};
37482template <> struct node_from_variant_t<963> { using type = SgAsmCilEventMap; };
37483
37484// Class: AsmCilExportedType
37485template <> struct describe_field_t<SgAsmCilExportedType,uint32_t,&SgAsmCilExportedType::p_EventFlags> {
37487 using field_type = uint32_t;
37488 static constexpr size_t position{0};
37489 static constexpr char const * const name{"EventFlags"};
37490 static constexpr char const * const typestr{"uint32_t"};
37491 static constexpr bool traverse{false};
37492 static constexpr auto mbr_ptr{&SgAsmCilExportedType::p_EventFlags};
37493 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37494 using bind = Desc<SgAsmCilExportedType, uint32_t SgAsmCilExportedType::*, &SgAsmCilExportedType::p_EventFlags>;
37495};
37496template <> struct describe_field_t<SgAsmCilExportedType,uint32_t,&SgAsmCilExportedType::p_TypeDefIdName> {
37498 using field_type = uint32_t;
37499 static constexpr size_t position{1};
37500 static constexpr char const * const name{"TypeDefIdName"};
37501 static constexpr char const * const typestr{"uint32_t"};
37502 static constexpr bool traverse{false};
37503 static constexpr auto mbr_ptr{&SgAsmCilExportedType::p_TypeDefIdName};
37504 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37505 using bind = Desc<SgAsmCilExportedType, uint32_t SgAsmCilExportedType::*, &SgAsmCilExportedType::p_TypeDefIdName>;
37506};
37507template <> struct describe_field_t<SgAsmCilExportedType,uint32_t,&SgAsmCilExportedType::p_TypeName> {
37509 using field_type = uint32_t;
37510 static constexpr size_t position{2};
37511 static constexpr char const * const name{"TypeName"};
37512 static constexpr char const * const typestr{"uint32_t"};
37513 static constexpr bool traverse{false};
37514 static constexpr auto mbr_ptr{&SgAsmCilExportedType::p_TypeName};
37515 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37516 using bind = Desc<SgAsmCilExportedType, uint32_t SgAsmCilExportedType::*, &SgAsmCilExportedType::p_TypeName>;
37517};
37518template <> struct describe_field_t<SgAsmCilExportedType,uint32_t,&SgAsmCilExportedType::p_TypeNamespace> {
37520 using field_type = uint32_t;
37521 static constexpr size_t position{3};
37522 static constexpr char const * const name{"TypeNamespace"};
37523 static constexpr char const * const typestr{"uint32_t"};
37524 static constexpr bool traverse{false};
37525 static constexpr auto mbr_ptr{&SgAsmCilExportedType::p_TypeNamespace};
37526 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37527 using bind = Desc<SgAsmCilExportedType, uint32_t SgAsmCilExportedType::*, &SgAsmCilExportedType::p_TypeNamespace>;
37528};
37529template <> struct describe_field_t<SgAsmCilExportedType,uint32_t,&SgAsmCilExportedType::p_Implementation> {
37531 using field_type = uint32_t;
37532 static constexpr size_t position{4};
37533 static constexpr char const * const name{"Implementation"};
37534 static constexpr char const * const typestr{"uint32_t"};
37535 static constexpr bool traverse{false};
37536 static constexpr auto mbr_ptr{&SgAsmCilExportedType::p_Implementation};
37537 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37538 using bind = Desc<SgAsmCilExportedType, uint32_t SgAsmCilExportedType::*, &SgAsmCilExportedType::p_Implementation>;
37539};
37549template <> struct node_from_variant_t<964> { using type = SgAsmCilExportedType; };
37550
37551// Class: AsmCilField
37552template <> struct describe_field_t<SgAsmCilField,uint16_t,&SgAsmCilField::p_Flags> {
37553 using parent = SgAsmCilField;
37554 using field_type = uint16_t;
37555 static constexpr size_t position{0};
37556 static constexpr char const * const name{"Flags"};
37557 static constexpr char const * const typestr{"uint16_t"};
37558 static constexpr bool traverse{false};
37559 static constexpr auto mbr_ptr{&SgAsmCilField::p_Flags};
37560 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37561 using bind = Desc<SgAsmCilField, uint16_t SgAsmCilField::*, &SgAsmCilField::p_Flags>;
37562};
37563template <> struct describe_field_t<SgAsmCilField,uint32_t,&SgAsmCilField::p_Name> {
37564 using parent = SgAsmCilField;
37565 using field_type = uint32_t;
37566 static constexpr size_t position{1};
37567 static constexpr char const * const name{"Name"};
37568 static constexpr char const * const typestr{"uint32_t"};
37569 static constexpr bool traverse{false};
37570 static constexpr auto mbr_ptr{&SgAsmCilField::p_Name};
37571 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37572 using bind = Desc<SgAsmCilField, uint32_t SgAsmCilField::*, &SgAsmCilField::p_Name>;
37573};
37574template <> struct describe_field_t<SgAsmCilField,uint32_t,&SgAsmCilField::p_Signature> {
37575 using parent = SgAsmCilField;
37576 using field_type = uint32_t;
37577 static constexpr size_t position{2};
37578 static constexpr char const * const name{"Signature"};
37579 static constexpr char const * const typestr{"uint32_t"};
37580 static constexpr bool traverse{false};
37581 static constexpr auto mbr_ptr{&SgAsmCilField::p_Signature};
37582 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37583 using bind = Desc<SgAsmCilField, uint32_t SgAsmCilField::*, &SgAsmCilField::p_Signature>;
37584};
37585template <> struct describe_node_t<SgAsmCilField> {
37586 using node = SgAsmCilField;
37587 using base = SgAsmCilMetadata;
37588 static constexpr char const * const name{"AsmCilField"};
37589 static constexpr unsigned long variant{965};
37590 static constexpr bool concrete{true};
37591 using subclasses_t = mp::List<>;
37593};
37594template <> struct node_from_variant_t<965> { using type = SgAsmCilField; };
37595
37596// Class: AsmCilFieldLayout
37597template <> struct describe_field_t<SgAsmCilFieldLayout,uint32_t,&SgAsmCilFieldLayout::p_Offset> {
37599 using field_type = uint32_t;
37600 static constexpr size_t position{0};
37601 static constexpr char const * const name{"Offset"};
37602 static constexpr char const * const typestr{"uint32_t"};
37603 static constexpr bool traverse{false};
37604 static constexpr auto mbr_ptr{&SgAsmCilFieldLayout::p_Offset};
37605 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37606 using bind = Desc<SgAsmCilFieldLayout, uint32_t SgAsmCilFieldLayout::*, &SgAsmCilFieldLayout::p_Offset>;
37607};
37608template <> struct describe_field_t<SgAsmCilFieldLayout,uint32_t,&SgAsmCilFieldLayout::p_Field> {
37610 using field_type = uint32_t;
37611 static constexpr size_t position{1};
37612 static constexpr char const * const name{"Field"};
37613 static constexpr char const * const typestr{"uint32_t"};
37614 static constexpr bool traverse{false};
37615 static constexpr auto mbr_ptr{&SgAsmCilFieldLayout::p_Field};
37616 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37617 using bind = Desc<SgAsmCilFieldLayout, uint32_t SgAsmCilFieldLayout::*, &SgAsmCilFieldLayout::p_Field>;
37618};
37620 using node = SgAsmCilFieldLayout;
37621 using base = SgAsmCilMetadata;
37622 static constexpr char const * const name{"AsmCilFieldLayout"};
37623 static constexpr unsigned long variant{966};
37624 static constexpr bool concrete{true};
37625 using subclasses_t = mp::List<>;
37627};
37628template <> struct node_from_variant_t<966> { using type = SgAsmCilFieldLayout; };
37629
37630// Class: AsmCilFieldMarshal
37631template <> struct describe_field_t<SgAsmCilFieldMarshal,uint32_t,&SgAsmCilFieldMarshal::p_Parent> {
37633 using field_type = uint32_t;
37634 static constexpr size_t position{0};
37635 static constexpr char const * const name{"Parent"};
37636 static constexpr char const * const typestr{"uint32_t"};
37637 static constexpr bool traverse{false};
37638 static constexpr auto mbr_ptr{&SgAsmCilFieldMarshal::p_Parent};
37639 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37640 using bind = Desc<SgAsmCilFieldMarshal, uint32_t SgAsmCilFieldMarshal::*, &SgAsmCilFieldMarshal::p_Parent>;
37641};
37642template <> struct describe_field_t<SgAsmCilFieldMarshal,uint32_t,&SgAsmCilFieldMarshal::p_NativeType> {
37644 using field_type = uint32_t;
37645 static constexpr size_t position{1};
37646 static constexpr char const * const name{"NativeType"};
37647 static constexpr char const * const typestr{"uint32_t"};
37648 static constexpr bool traverse{false};
37649 static constexpr auto mbr_ptr{&SgAsmCilFieldMarshal::p_NativeType};
37650 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37651 using bind = Desc<SgAsmCilFieldMarshal, uint32_t SgAsmCilFieldMarshal::*, &SgAsmCilFieldMarshal::p_NativeType>;
37652};
37654 using node = SgAsmCilFieldMarshal;
37655 using base = SgAsmCilMetadata;
37656 static constexpr char const * const name{"AsmCilFieldMarshal"};
37657 static constexpr unsigned long variant{967};
37658 static constexpr bool concrete{true};
37659 using subclasses_t = mp::List<>;
37661};
37662template <> struct node_from_variant_t<967> { using type = SgAsmCilFieldMarshal; };
37663
37664// Class: AsmCilFieldRVA
37665template <> struct describe_field_t<SgAsmCilFieldRVA,uint32_t,&SgAsmCilFieldRVA::p_RVA> {
37666 using parent = SgAsmCilFieldRVA;
37667 using field_type = uint32_t;
37668 static constexpr size_t position{0};
37669 static constexpr char const * const name{"RVA"};
37670 static constexpr char const * const typestr{"uint32_t"};
37671 static constexpr bool traverse{false};
37672 static constexpr auto mbr_ptr{&SgAsmCilFieldRVA::p_RVA};
37673 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37674 using bind = Desc<SgAsmCilFieldRVA, uint32_t SgAsmCilFieldRVA::*, &SgAsmCilFieldRVA::p_RVA>;
37675};
37676template <> struct describe_field_t<SgAsmCilFieldRVA,uint32_t,&SgAsmCilFieldRVA::p_Field> {
37677 using parent = SgAsmCilFieldRVA;
37678 using field_type = uint32_t;
37679 static constexpr size_t position{1};
37680 static constexpr char const * const name{"Field"};
37681 static constexpr char const * const typestr{"uint32_t"};
37682 static constexpr bool traverse{false};
37683 static constexpr auto mbr_ptr{&SgAsmCilFieldRVA::p_Field};
37684 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37685 using bind = Desc<SgAsmCilFieldRVA, uint32_t SgAsmCilFieldRVA::*, &SgAsmCilFieldRVA::p_Field>;
37686};
37688 using node = SgAsmCilFieldRVA;
37689 using base = SgAsmCilMetadata;
37690 static constexpr char const * const name{"AsmCilFieldRVA"};
37691 static constexpr unsigned long variant{968};
37692 static constexpr bool concrete{true};
37693 using subclasses_t = mp::List<>;
37695};
37696template <> struct node_from_variant_t<968> { using type = SgAsmCilFieldRVA; };
37697
37698// Class: AsmCilFile
37699template <> struct describe_field_t<SgAsmCilFile,uint32_t,&SgAsmCilFile::p_Flags> {
37700 using parent = SgAsmCilFile;
37701 using field_type = uint32_t;
37702 static constexpr size_t position{0};
37703 static constexpr char const * const name{"Flags"};
37704 static constexpr char const * const typestr{"uint32_t"};
37705 static constexpr bool traverse{false};
37706 static constexpr auto mbr_ptr{&SgAsmCilFile::p_Flags};
37707 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37708 using bind = Desc<SgAsmCilFile, uint32_t SgAsmCilFile::*, &SgAsmCilFile::p_Flags>;
37709};
37710template <> struct describe_field_t<SgAsmCilFile,uint32_t,&SgAsmCilFile::p_Name> {
37711 using parent = SgAsmCilFile;
37712 using field_type = uint32_t;
37713 static constexpr size_t position{1};
37714 static constexpr char const * const name{"Name"};
37715 static constexpr char const * const typestr{"uint32_t"};
37716 static constexpr bool traverse{false};
37717 static constexpr auto mbr_ptr{&SgAsmCilFile::p_Name};
37718 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37719 using bind = Desc<SgAsmCilFile, uint32_t SgAsmCilFile::*, &SgAsmCilFile::p_Name>;
37720};
37721template <> struct describe_field_t<SgAsmCilFile,uint32_t,&SgAsmCilFile::p_HashValue> {
37722 using parent = SgAsmCilFile;
37723 using field_type = uint32_t;
37724 static constexpr size_t position{2};
37725 static constexpr char const * const name{"HashValue"};
37726 static constexpr char const * const typestr{"uint32_t"};
37727 static constexpr bool traverse{false};
37728 static constexpr auto mbr_ptr{&SgAsmCilFile::p_HashValue};
37729 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37730 using bind = Desc<SgAsmCilFile, uint32_t SgAsmCilFile::*, &SgAsmCilFile::p_HashValue>;
37731};
37732template <> struct describe_node_t<SgAsmCilFile> {
37733 using node = SgAsmCilFile;
37734 using base = SgAsmCilMetadata;
37735 static constexpr char const * const name{"AsmCilFile"};
37736 static constexpr unsigned long variant{969};
37737 static constexpr bool concrete{true};
37738 using subclasses_t = mp::List<>;
37740};
37741template <> struct node_from_variant_t<969> { using type = SgAsmCilFile; };
37742
37743// Class: AsmCilGenericParam
37744template <> struct describe_field_t<SgAsmCilGenericParam,uint16_t,&SgAsmCilGenericParam::p_Number> {
37746 using field_type = uint16_t;
37747 static constexpr size_t position{0};
37748 static constexpr char const * const name{"Number"};
37749 static constexpr char const * const typestr{"uint16_t"};
37750 static constexpr bool traverse{false};
37751 static constexpr auto mbr_ptr{&SgAsmCilGenericParam::p_Number};
37752 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37753 using bind = Desc<SgAsmCilGenericParam, uint16_t SgAsmCilGenericParam::*, &SgAsmCilGenericParam::p_Number>;
37754};
37755template <> struct describe_field_t<SgAsmCilGenericParam,uint16_t,&SgAsmCilGenericParam::p_Flags> {
37757 using field_type = uint16_t;
37758 static constexpr size_t position{1};
37759 static constexpr char const * const name{"Flags"};
37760 static constexpr char const * const typestr{"uint16_t"};
37761 static constexpr bool traverse{false};
37762 static constexpr auto mbr_ptr{&SgAsmCilGenericParam::p_Flags};
37763 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37764 using bind = Desc<SgAsmCilGenericParam, uint16_t SgAsmCilGenericParam::*, &SgAsmCilGenericParam::p_Flags>;
37765};
37766template <> struct describe_field_t<SgAsmCilGenericParam,uint32_t,&SgAsmCilGenericParam::p_Owner> {
37768 using field_type = uint32_t;
37769 static constexpr size_t position{2};
37770 static constexpr char const * const name{"Owner"};
37771 static constexpr char const * const typestr{"uint32_t"};
37772 static constexpr bool traverse{false};
37773 static constexpr auto mbr_ptr{&SgAsmCilGenericParam::p_Owner};
37774 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37775 using bind = Desc<SgAsmCilGenericParam, uint32_t SgAsmCilGenericParam::*, &SgAsmCilGenericParam::p_Owner>;
37776};
37777template <> struct describe_field_t<SgAsmCilGenericParam,uint32_t,&SgAsmCilGenericParam::p_Name> {
37779 using field_type = uint32_t;
37780 static constexpr size_t position{3};
37781 static constexpr char const * const name{"Name"};
37782 static constexpr char const * const typestr{"uint32_t"};
37783 static constexpr bool traverse{false};
37784 static constexpr auto mbr_ptr{&SgAsmCilGenericParam::p_Name};
37785 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37786 using bind = Desc<SgAsmCilGenericParam, uint32_t SgAsmCilGenericParam::*, &SgAsmCilGenericParam::p_Name>;
37787};
37797template <> struct node_from_variant_t<970> { using type = SgAsmCilGenericParam; };
37798
37799// Class: AsmCilGenericParamConstraint
37800template <> struct describe_field_t<SgAsmCilGenericParamConstraint,uint32_t,&SgAsmCilGenericParamConstraint::p_Owner> {
37802 using field_type = uint32_t;
37803 static constexpr size_t position{0};
37804 static constexpr char const * const name{"Owner"};
37805 static constexpr char const * const typestr{"uint32_t"};
37806 static constexpr bool traverse{false};
37807 static constexpr auto mbr_ptr{&SgAsmCilGenericParamConstraint::p_Owner};
37808 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37809 using bind = Desc<SgAsmCilGenericParamConstraint, uint32_t SgAsmCilGenericParamConstraint::*, &SgAsmCilGenericParamConstraint::p_Owner>;
37810};
37811template <> struct describe_field_t<SgAsmCilGenericParamConstraint,uint32_t,&SgAsmCilGenericParamConstraint::p_Constraint> {
37813 using field_type = uint32_t;
37814 static constexpr size_t position{1};
37815 static constexpr char const * const name{"Constraint"};
37816 static constexpr char const * const typestr{"uint32_t"};
37817 static constexpr bool traverse{false};
37818 static constexpr auto mbr_ptr{&SgAsmCilGenericParamConstraint::p_Constraint};
37819 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37820 using bind = Desc<SgAsmCilGenericParamConstraint, uint32_t SgAsmCilGenericParamConstraint::*, &SgAsmCilGenericParamConstraint::p_Constraint>;
37821};
37824 using base = SgAsmCilMetadata;
37825 static constexpr char const * const name{"AsmCilGenericParamConstraint"};
37826 static constexpr unsigned long variant{971};
37827 static constexpr bool concrete{true};
37828 using subclasses_t = mp::List<>;
37830};
37831template <> struct node_from_variant_t<971> { using type = SgAsmCilGenericParamConstraint; };
37832
37833// Class: AsmCilImplMap
37834template <> struct describe_field_t<SgAsmCilImplMap,uint16_t,&SgAsmCilImplMap::p_MappingFlags> {
37835 using parent = SgAsmCilImplMap;
37836 using field_type = uint16_t;
37837 static constexpr size_t position{0};
37838 static constexpr char const * const name{"MappingFlags"};
37839 static constexpr char const * const typestr{"uint16_t"};
37840 static constexpr bool traverse{false};
37841 static constexpr auto mbr_ptr{&SgAsmCilImplMap::p_MappingFlags};
37842 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37843 using bind = Desc<SgAsmCilImplMap, uint16_t SgAsmCilImplMap::*, &SgAsmCilImplMap::p_MappingFlags>;
37844};
37845template <> struct describe_field_t<SgAsmCilImplMap,uint32_t,&SgAsmCilImplMap::p_MemberForwarded> {
37846 using parent = SgAsmCilImplMap;
37847 using field_type = uint32_t;
37848 static constexpr size_t position{1};
37849 static constexpr char const * const name{"MemberForwarded"};
37850 static constexpr char const * const typestr{"uint32_t"};
37851 static constexpr bool traverse{false};
37852 static constexpr auto mbr_ptr{&SgAsmCilImplMap::p_MemberForwarded};
37853 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37854 using bind = Desc<SgAsmCilImplMap, uint32_t SgAsmCilImplMap::*, &SgAsmCilImplMap::p_MemberForwarded>;
37855};
37856template <> struct describe_field_t<SgAsmCilImplMap,uint32_t,&SgAsmCilImplMap::p_ImportName> {
37857 using parent = SgAsmCilImplMap;
37858 using field_type = uint32_t;
37859 static constexpr size_t position{2};
37860 static constexpr char const * const name{"ImportName"};
37861 static constexpr char const * const typestr{"uint32_t"};
37862 static constexpr bool traverse{false};
37863 static constexpr auto mbr_ptr{&SgAsmCilImplMap::p_ImportName};
37864 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37865 using bind = Desc<SgAsmCilImplMap, uint32_t SgAsmCilImplMap::*, &SgAsmCilImplMap::p_ImportName>;
37866};
37867template <> struct describe_field_t<SgAsmCilImplMap,uint32_t,&SgAsmCilImplMap::p_ImportScope> {
37868 using parent = SgAsmCilImplMap;
37869 using field_type = uint32_t;
37870 static constexpr size_t position{3};
37871 static constexpr char const * const name{"ImportScope"};
37872 static constexpr char const * const typestr{"uint32_t"};
37873 static constexpr bool traverse{false};
37874 static constexpr auto mbr_ptr{&SgAsmCilImplMap::p_ImportScope};
37875 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37876 using bind = Desc<SgAsmCilImplMap, uint32_t SgAsmCilImplMap::*, &SgAsmCilImplMap::p_ImportScope>;
37877};
37887template <> struct node_from_variant_t<972> { using type = SgAsmCilImplMap; };
37888
37889// Class: AsmCilInterfaceImpl
37890template <> struct describe_field_t<SgAsmCilInterfaceImpl,uint32_t,&SgAsmCilInterfaceImpl::p_Class> {
37892 using field_type = uint32_t;
37893 static constexpr size_t position{0};
37894 static constexpr char const * const name{"Class"};
37895 static constexpr char const * const typestr{"uint32_t"};
37896 static constexpr bool traverse{false};
37897 static constexpr auto mbr_ptr{&SgAsmCilInterfaceImpl::p_Class};
37898 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37899 using bind = Desc<SgAsmCilInterfaceImpl, uint32_t SgAsmCilInterfaceImpl::*, &SgAsmCilInterfaceImpl::p_Class>;
37900};
37901template <> struct describe_field_t<SgAsmCilInterfaceImpl,uint32_t,&SgAsmCilInterfaceImpl::p_Interface> {
37903 using field_type = uint32_t;
37904 static constexpr size_t position{1};
37905 static constexpr char const * const name{"Interface"};
37906 static constexpr char const * const typestr{"uint32_t"};
37907 static constexpr bool traverse{false};
37908 static constexpr auto mbr_ptr{&SgAsmCilInterfaceImpl::p_Interface};
37909 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37910 using bind = Desc<SgAsmCilInterfaceImpl, uint32_t SgAsmCilInterfaceImpl::*, &SgAsmCilInterfaceImpl::p_Interface>;
37911};
37914 using base = SgAsmCilMetadata;
37915 static constexpr char const * const name{"AsmCilInterfaceImpl"};
37916 static constexpr unsigned long variant{973};
37917 static constexpr bool concrete{true};
37918 using subclasses_t = mp::List<>;
37920};
37921template <> struct node_from_variant_t<973> { using type = SgAsmCilInterfaceImpl; };
37922
37923// Class: AsmCilManifestResource
37924template <> struct describe_field_t<SgAsmCilManifestResource,uint32_t,&SgAsmCilManifestResource::p_Offset> {
37926 using field_type = uint32_t;
37927 static constexpr size_t position{0};
37928 static constexpr char const * const name{"Offset"};
37929 static constexpr char const * const typestr{"uint32_t"};
37930 static constexpr bool traverse{false};
37931 static constexpr auto mbr_ptr{&SgAsmCilManifestResource::p_Offset};
37932 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37933 using bind = Desc<SgAsmCilManifestResource, uint32_t SgAsmCilManifestResource::*, &SgAsmCilManifestResource::p_Offset>;
37934};
37935template <> struct describe_field_t<SgAsmCilManifestResource,uint32_t,&SgAsmCilManifestResource::p_Flags> {
37937 using field_type = uint32_t;
37938 static constexpr size_t position{1};
37939 static constexpr char const * const name{"Flags"};
37940 static constexpr char const * const typestr{"uint32_t"};
37941 static constexpr bool traverse{false};
37942 static constexpr auto mbr_ptr{&SgAsmCilManifestResource::p_Flags};
37943 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37944 using bind = Desc<SgAsmCilManifestResource, uint32_t SgAsmCilManifestResource::*, &SgAsmCilManifestResource::p_Flags>;
37945};
37946template <> struct describe_field_t<SgAsmCilManifestResource,uint32_t,&SgAsmCilManifestResource::p_Name> {
37948 using field_type = uint32_t;
37949 static constexpr size_t position{2};
37950 static constexpr char const * const name{"Name"};
37951 static constexpr char const * const typestr{"uint32_t"};
37952 static constexpr bool traverse{false};
37953 static constexpr auto mbr_ptr{&SgAsmCilManifestResource::p_Name};
37954 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37955 using bind = Desc<SgAsmCilManifestResource, uint32_t SgAsmCilManifestResource::*, &SgAsmCilManifestResource::p_Name>;
37956};
37957template <> struct describe_field_t<SgAsmCilManifestResource,uint32_t,&SgAsmCilManifestResource::p_Implementation> {
37959 using field_type = uint32_t;
37960 static constexpr size_t position{3};
37961 static constexpr char const * const name{"Implementation"};
37962 static constexpr char const * const typestr{"uint32_t"};
37963 static constexpr bool traverse{false};
37964 static constexpr auto mbr_ptr{&SgAsmCilManifestResource::p_Implementation};
37965 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37966 using bind = Desc<SgAsmCilManifestResource, uint32_t SgAsmCilManifestResource::*, &SgAsmCilManifestResource::p_Implementation>;
37967};
37977template <> struct node_from_variant_t<974> { using type = SgAsmCilManifestResource; };
37978
37979// Class: AsmCilMemberRef
37980template <> struct describe_field_t<SgAsmCilMemberRef,uint32_t,&SgAsmCilMemberRef::p_Class> {
37981 using parent = SgAsmCilMemberRef;
37982 using field_type = uint32_t;
37983 static constexpr size_t position{0};
37984 static constexpr char const * const name{"Class"};
37985 static constexpr char const * const typestr{"uint32_t"};
37986 static constexpr bool traverse{false};
37987 static constexpr auto mbr_ptr{&SgAsmCilMemberRef::p_Class};
37988 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
37989 using bind = Desc<SgAsmCilMemberRef, uint32_t SgAsmCilMemberRef::*, &SgAsmCilMemberRef::p_Class>;
37990};
37991template <> struct describe_field_t<SgAsmCilMemberRef,uint32_t,&SgAsmCilMemberRef::p_Name> {
37992 using parent = SgAsmCilMemberRef;
37993 using field_type = uint32_t;
37994 static constexpr size_t position{1};
37995 static constexpr char const * const name{"Name"};
37996 static constexpr char const * const typestr{"uint32_t"};
37997 static constexpr bool traverse{false};
37998 static constexpr auto mbr_ptr{&SgAsmCilMemberRef::p_Name};
37999 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38000 using bind = Desc<SgAsmCilMemberRef, uint32_t SgAsmCilMemberRef::*, &SgAsmCilMemberRef::p_Name>;
38001};
38002template <> struct describe_field_t<SgAsmCilMemberRef,uint32_t,&SgAsmCilMemberRef::p_Signature> {
38003 using parent = SgAsmCilMemberRef;
38004 using field_type = uint32_t;
38005 static constexpr size_t position{2};
38006 static constexpr char const * const name{"Signature"};
38007 static constexpr char const * const typestr{"uint32_t"};
38008 static constexpr bool traverse{false};
38009 static constexpr auto mbr_ptr{&SgAsmCilMemberRef::p_Signature};
38010 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38011 using bind = Desc<SgAsmCilMemberRef, uint32_t SgAsmCilMemberRef::*, &SgAsmCilMemberRef::p_Signature>;
38012};
38014 using node = SgAsmCilMemberRef;
38015 using base = SgAsmCilMetadata;
38016 static constexpr char const * const name{"AsmCilMemberRef"};
38017 static constexpr unsigned long variant{975};
38018 static constexpr bool concrete{true};
38019 using subclasses_t = mp::List<>;
38021};
38022template <> struct node_from_variant_t<975> { using type = SgAsmCilMemberRef; };
38023
38024// Class: AsmCilMethodDef
38025template <> struct describe_field_t<SgAsmCilMethodDef,uint32_t,&SgAsmCilMethodDef::p_RVA> {
38026 using parent = SgAsmCilMethodDef;
38027 using field_type = uint32_t;
38028 static constexpr size_t position{0};
38029 static constexpr char const * const name{"RVA"};
38030 static constexpr char const * const typestr{"uint32_t"};
38031 static constexpr bool traverse{false};
38032 static constexpr auto mbr_ptr{&SgAsmCilMethodDef::p_RVA};
38033 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38034 using bind = Desc<SgAsmCilMethodDef, uint32_t SgAsmCilMethodDef::*, &SgAsmCilMethodDef::p_RVA>;
38035};
38036template <> struct describe_field_t<SgAsmCilMethodDef,uint16_t,&SgAsmCilMethodDef::p_ImplFlags> {
38037 using parent = SgAsmCilMethodDef;
38038 using field_type = uint16_t;
38039 static constexpr size_t position{1};
38040 static constexpr char const * const name{"ImplFlags"};
38041 static constexpr char const * const typestr{"uint16_t"};
38042 static constexpr bool traverse{false};
38043 static constexpr auto mbr_ptr{&SgAsmCilMethodDef::p_ImplFlags};
38044 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38045 using bind = Desc<SgAsmCilMethodDef, uint16_t SgAsmCilMethodDef::*, &SgAsmCilMethodDef::p_ImplFlags>;
38046};
38047template <> struct describe_field_t<SgAsmCilMethodDef,uint16_t,&SgAsmCilMethodDef::p_Flags> {
38048 using parent = SgAsmCilMethodDef;
38049 using field_type = uint16_t;
38050 static constexpr size_t position{2};
38051 static constexpr char const * const name{"Flags"};
38052 static constexpr char const * const typestr{"uint16_t"};
38053 static constexpr bool traverse{false};
38054 static constexpr auto mbr_ptr{&SgAsmCilMethodDef::p_Flags};
38055 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38056 using bind = Desc<SgAsmCilMethodDef, uint16_t SgAsmCilMethodDef::*, &SgAsmCilMethodDef::p_Flags>;
38057};
38058template <> struct describe_field_t<SgAsmCilMethodDef,uint32_t,&SgAsmCilMethodDef::p_Name> {
38059 using parent = SgAsmCilMethodDef;
38060 using field_type = uint32_t;
38061 static constexpr size_t position{3};
38062 static constexpr char const * const name{"Name"};
38063 static constexpr char const * const typestr{"uint32_t"};
38064 static constexpr bool traverse{false};
38065 static constexpr auto mbr_ptr{&SgAsmCilMethodDef::p_Name};
38066 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38067 using bind = Desc<SgAsmCilMethodDef, uint32_t SgAsmCilMethodDef::*, &SgAsmCilMethodDef::p_Name>;
38068};
38069template <> struct describe_field_t<SgAsmCilMethodDef,uint32_t,&SgAsmCilMethodDef::p_Signature> {
38070 using parent = SgAsmCilMethodDef;
38071 using field_type = uint32_t;
38072 static constexpr size_t position{4};
38073 static constexpr char const * const name{"Signature"};
38074 static constexpr char const * const typestr{"uint32_t"};
38075 static constexpr bool traverse{false};
38076 static constexpr auto mbr_ptr{&SgAsmCilMethodDef::p_Signature};
38077 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38078 using bind = Desc<SgAsmCilMethodDef, uint32_t SgAsmCilMethodDef::*, &SgAsmCilMethodDef::p_Signature>;
38079};
38080template <> struct describe_field_t<SgAsmCilMethodDef,uint32_t,&SgAsmCilMethodDef::p_ParamList> {
38081 using parent = SgAsmCilMethodDef;
38082 using field_type = uint32_t;
38083 static constexpr size_t position{5};
38084 static constexpr char const * const name{"ParamList"};
38085 static constexpr char const * const typestr{"uint32_t"};
38086 static constexpr bool traverse{false};
38087 static constexpr auto mbr_ptr{&SgAsmCilMethodDef::p_ParamList};
38088 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38089 using bind = Desc<SgAsmCilMethodDef, uint32_t SgAsmCilMethodDef::*, &SgAsmCilMethodDef::p_ParamList>;
38090};
38091template <> struct describe_field_t<SgAsmCilMethodDef,SgAsmBlock*,&SgAsmCilMethodDef::p_body> {
38092 using parent = SgAsmCilMethodDef;
38093 using field_type = SgAsmBlock*;
38094 static constexpr size_t position{6};
38095 static constexpr char const * const name{"body"};
38096 static constexpr char const * const typestr{"SgAsmBlock*"};
38097 static constexpr bool traverse{false};
38098 static constexpr auto mbr_ptr{&SgAsmCilMethodDef::p_body};
38099 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38100 using bind = Desc<SgAsmCilMethodDef, SgAsmBlock* SgAsmCilMethodDef::*, &SgAsmCilMethodDef::p_body>;
38101};
38102template <> struct describe_field_t<SgAsmCilMethodDef,bool,&SgAsmCilMethodDef::p_initLocals> {
38103 using parent = SgAsmCilMethodDef;
38104 using field_type = bool;
38105 static constexpr size_t position{7};
38106 static constexpr char const * const name{"initLocals"};
38107 static constexpr char const * const typestr{"bool"};
38108 static constexpr bool traverse{false};
38109 static constexpr auto mbr_ptr{&SgAsmCilMethodDef::p_initLocals};
38110 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38111 using bind = Desc<SgAsmCilMethodDef, bool SgAsmCilMethodDef::*, &SgAsmCilMethodDef::p_initLocals>;
38112};
38113template <> struct describe_field_t<SgAsmCilMethodDef,uint32_t,&SgAsmCilMethodDef::p_stackSize> {
38114 using parent = SgAsmCilMethodDef;
38115 using field_type = uint32_t;
38116 static constexpr size_t position{8};
38117 static constexpr char const * const name{"stackSize"};
38118 static constexpr char const * const typestr{"uint32_t"};
38119 static constexpr bool traverse{false};
38120 static constexpr auto mbr_ptr{&SgAsmCilMethodDef::p_stackSize};
38121 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38122 using bind = Desc<SgAsmCilMethodDef, uint32_t SgAsmCilMethodDef::*, &SgAsmCilMethodDef::p_stackSize>;
38123};
38124template <> struct describe_field_t<SgAsmCilMethodDef,bool,&SgAsmCilMethodDef::p_hasMoreSections> {
38125 using parent = SgAsmCilMethodDef;
38126 using field_type = bool;
38127 static constexpr size_t position{9};
38128 static constexpr char const * const name{"hasMoreSections"};
38129 static constexpr char const * const typestr{"bool"};
38130 static constexpr bool traverse{false};
38131 static constexpr auto mbr_ptr{&SgAsmCilMethodDef::p_hasMoreSections};
38132 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38133 using bind = Desc<SgAsmCilMethodDef, bool SgAsmCilMethodDef::*, &SgAsmCilMethodDef::p_hasMoreSections>;
38134};
38135template <> struct describe_field_t<SgAsmCilMethodDef,uint32_t,&SgAsmCilMethodDef::p_localVarSigTok> {
38136 using parent = SgAsmCilMethodDef;
38137 using field_type = uint32_t;
38138 static constexpr size_t position{10};
38139 static constexpr char const * const name{"localVarSigTok"};
38140 static constexpr char const * const typestr{"uint32_t"};
38141 static constexpr bool traverse{false};
38142 static constexpr auto mbr_ptr{&SgAsmCilMethodDef::p_localVarSigTok};
38143 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38144 using bind = Desc<SgAsmCilMethodDef, uint32_t SgAsmCilMethodDef::*, &SgAsmCilMethodDef::p_localVarSigTok>;
38145};
38146template <> struct describe_field_t<SgAsmCilMethodDef,std::vector<SgAsmCilMethodData*>,&SgAsmCilMethodDef::p_methodData> {
38147 using parent = SgAsmCilMethodDef;
38148 using field_type = std::vector<SgAsmCilMethodData*>;
38149 static constexpr size_t position{11};
38150 static constexpr char const * const name{"methodData"};
38151 static constexpr char const * const typestr{"std::vector<SgAsmCilMethodData*>"};
38152 static constexpr bool traverse{false};
38153 static constexpr auto mbr_ptr{&SgAsmCilMethodDef::p_methodData};
38154 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38155 using bind = Desc<SgAsmCilMethodDef, std::vector<SgAsmCilMethodData*> SgAsmCilMethodDef::*, &SgAsmCilMethodDef::p_methodData>;
38156};
38166template <> struct node_from_variant_t<976> { using type = SgAsmCilMethodDef; };
38167
38168// Class: AsmCilMethodImpl
38169template <> struct describe_field_t<SgAsmCilMethodImpl,uint32_t,&SgAsmCilMethodImpl::p_Class> {
38170 using parent = SgAsmCilMethodImpl;
38171 using field_type = uint32_t;
38172 static constexpr size_t position{0};
38173 static constexpr char const * const name{"Class"};
38174 static constexpr char const * const typestr{"uint32_t"};
38175 static constexpr bool traverse{false};
38176 static constexpr auto mbr_ptr{&SgAsmCilMethodImpl::p_Class};
38177 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38178 using bind = Desc<SgAsmCilMethodImpl, uint32_t SgAsmCilMethodImpl::*, &SgAsmCilMethodImpl::p_Class>;
38179};
38180template <> struct describe_field_t<SgAsmCilMethodImpl,uint32_t,&SgAsmCilMethodImpl::p_MethodBody> {
38181 using parent = SgAsmCilMethodImpl;
38182 using field_type = uint32_t;
38183 static constexpr size_t position{1};
38184 static constexpr char const * const name{"MethodBody"};
38185 static constexpr char const * const typestr{"uint32_t"};
38186 static constexpr bool traverse{false};
38187 static constexpr auto mbr_ptr{&SgAsmCilMethodImpl::p_MethodBody};
38188 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38189 using bind = Desc<SgAsmCilMethodImpl, uint32_t SgAsmCilMethodImpl::*, &SgAsmCilMethodImpl::p_MethodBody>;
38190};
38191template <> struct describe_field_t<SgAsmCilMethodImpl,uint32_t,&SgAsmCilMethodImpl::p_MethodDeclaration> {
38192 using parent = SgAsmCilMethodImpl;
38193 using field_type = uint32_t;
38194 static constexpr size_t position{2};
38195 static constexpr char const * const name{"MethodDeclaration"};
38196 static constexpr char const * const typestr{"uint32_t"};
38197 static constexpr bool traverse{false};
38198 static constexpr auto mbr_ptr{&SgAsmCilMethodImpl::p_MethodDeclaration};
38199 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38200 using bind = Desc<SgAsmCilMethodImpl, uint32_t SgAsmCilMethodImpl::*, &SgAsmCilMethodImpl::p_MethodDeclaration>;
38201};
38203 using node = SgAsmCilMethodImpl;
38204 using base = SgAsmCilMetadata;
38205 static constexpr char const * const name{"AsmCilMethodImpl"};
38206 static constexpr unsigned long variant{977};
38207 static constexpr bool concrete{true};
38208 using subclasses_t = mp::List<>;
38210};
38211template <> struct node_from_variant_t<977> { using type = SgAsmCilMethodImpl; };
38212
38213// Class: AsmCilMethodSemantics
38214template <> struct describe_field_t<SgAsmCilMethodSemantics,uint16_t,&SgAsmCilMethodSemantics::p_Semantics> {
38216 using field_type = uint16_t;
38217 static constexpr size_t position{0};
38218 static constexpr char const * const name{"Semantics"};
38219 static constexpr char const * const typestr{"uint16_t"};
38220 static constexpr bool traverse{false};
38221 static constexpr auto mbr_ptr{&SgAsmCilMethodSemantics::p_Semantics};
38222 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38223 using bind = Desc<SgAsmCilMethodSemantics, uint16_t SgAsmCilMethodSemantics::*, &SgAsmCilMethodSemantics::p_Semantics>;
38224};
38225template <> struct describe_field_t<SgAsmCilMethodSemantics,uint32_t,&SgAsmCilMethodSemantics::p_Method> {
38227 using field_type = uint32_t;
38228 static constexpr size_t position{1};
38229 static constexpr char const * const name{"Method"};
38230 static constexpr char const * const typestr{"uint32_t"};
38231 static constexpr bool traverse{false};
38232 static constexpr auto mbr_ptr{&SgAsmCilMethodSemantics::p_Method};
38233 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38234 using bind = Desc<SgAsmCilMethodSemantics, uint32_t SgAsmCilMethodSemantics::*, &SgAsmCilMethodSemantics::p_Method>;
38235};
38236template <> struct describe_field_t<SgAsmCilMethodSemantics,uint32_t,&SgAsmCilMethodSemantics::p_Association> {
38238 using field_type = uint32_t;
38239 static constexpr size_t position{2};
38240 static constexpr char const * const name{"Association"};
38241 static constexpr char const * const typestr{"uint32_t"};
38242 static constexpr bool traverse{false};
38243 static constexpr auto mbr_ptr{&SgAsmCilMethodSemantics::p_Association};
38244 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38245 using bind = Desc<SgAsmCilMethodSemantics, uint32_t SgAsmCilMethodSemantics::*, &SgAsmCilMethodSemantics::p_Association>;
38246};
38249 using base = SgAsmCilMetadata;
38250 static constexpr char const * const name{"AsmCilMethodSemantics"};
38251 static constexpr unsigned long variant{978};
38252 static constexpr bool concrete{true};
38253 using subclasses_t = mp::List<>;
38255};
38256template <> struct node_from_variant_t<978> { using type = SgAsmCilMethodSemantics; };
38257
38258// Class: AsmCilMethodSpec
38259template <> struct describe_field_t<SgAsmCilMethodSpec,uint32_t,&SgAsmCilMethodSpec::p_Method> {
38260 using parent = SgAsmCilMethodSpec;
38261 using field_type = uint32_t;
38262 static constexpr size_t position{0};
38263 static constexpr char const * const name{"Method"};
38264 static constexpr char const * const typestr{"uint32_t"};
38265 static constexpr bool traverse{false};
38266 static constexpr auto mbr_ptr{&SgAsmCilMethodSpec::p_Method};
38267 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38268 using bind = Desc<SgAsmCilMethodSpec, uint32_t SgAsmCilMethodSpec::*, &SgAsmCilMethodSpec::p_Method>;
38269};
38270template <> struct describe_field_t<SgAsmCilMethodSpec,uint32_t,&SgAsmCilMethodSpec::p_Instantiation> {
38271 using parent = SgAsmCilMethodSpec;
38272 using field_type = uint32_t;
38273 static constexpr size_t position{1};
38274 static constexpr char const * const name{"Instantiation"};
38275 static constexpr char const * const typestr{"uint32_t"};
38276 static constexpr bool traverse{false};
38277 static constexpr auto mbr_ptr{&SgAsmCilMethodSpec::p_Instantiation};
38278 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38279 using bind = Desc<SgAsmCilMethodSpec, uint32_t SgAsmCilMethodSpec::*, &SgAsmCilMethodSpec::p_Instantiation>;
38280};
38282 using node = SgAsmCilMethodSpec;
38283 using base = SgAsmCilMetadata;
38284 static constexpr char const * const name{"AsmCilMethodSpec"};
38285 static constexpr unsigned long variant{979};
38286 static constexpr bool concrete{true};
38287 using subclasses_t = mp::List<>;
38289};
38290template <> struct node_from_variant_t<979> { using type = SgAsmCilMethodSpec; };
38291
38292// Class: AsmCilModule
38293template <> struct describe_field_t<SgAsmCilModule,uint16_t,&SgAsmCilModule::p_Generation> {
38294 using parent = SgAsmCilModule;
38295 using field_type = uint16_t;
38296 static constexpr size_t position{0};
38297 static constexpr char const * const name{"Generation"};
38298 static constexpr char const * const typestr{"uint16_t"};
38299 static constexpr bool traverse{false};
38300 static constexpr auto mbr_ptr{&SgAsmCilModule::p_Generation};
38301 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38302 using bind = Desc<SgAsmCilModule, uint16_t SgAsmCilModule::*, &SgAsmCilModule::p_Generation>;
38303};
38304template <> struct describe_field_t<SgAsmCilModule,uint32_t,&SgAsmCilModule::p_Name> {
38305 using parent = SgAsmCilModule;
38306 using field_type = uint32_t;
38307 static constexpr size_t position{1};
38308 static constexpr char const * const name{"Name"};
38309 static constexpr char const * const typestr{"uint32_t"};
38310 static constexpr bool traverse{false};
38311 static constexpr auto mbr_ptr{&SgAsmCilModule::p_Name};
38312 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38313 using bind = Desc<SgAsmCilModule, uint32_t SgAsmCilModule::*, &SgAsmCilModule::p_Name>;
38314};
38315template <> struct describe_field_t<SgAsmCilModule,uint32_t,&SgAsmCilModule::p_Mvid> {
38316 using parent = SgAsmCilModule;
38317 using field_type = uint32_t;
38318 static constexpr size_t position{2};
38319 static constexpr char const * const name{"Mvid"};
38320 static constexpr char const * const typestr{"uint32_t"};
38321 static constexpr bool traverse{false};
38322 static constexpr auto mbr_ptr{&SgAsmCilModule::p_Mvid};
38323 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38324 using bind = Desc<SgAsmCilModule, uint32_t SgAsmCilModule::*, &SgAsmCilModule::p_Mvid>;
38325};
38326template <> struct describe_field_t<SgAsmCilModule,uint32_t,&SgAsmCilModule::p_Encld> {
38327 using parent = SgAsmCilModule;
38328 using field_type = uint32_t;
38329 static constexpr size_t position{3};
38330 static constexpr char const * const name{"Encld"};
38331 static constexpr char const * const typestr{"uint32_t"};
38332 static constexpr bool traverse{false};
38333 static constexpr auto mbr_ptr{&SgAsmCilModule::p_Encld};
38334 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38335 using bind = Desc<SgAsmCilModule, uint32_t SgAsmCilModule::*, &SgAsmCilModule::p_Encld>;
38336};
38337template <> struct describe_field_t<SgAsmCilModule,uint32_t,&SgAsmCilModule::p_EncBaseId> {
38338 using parent = SgAsmCilModule;
38339 using field_type = uint32_t;
38340 static constexpr size_t position{4};
38341 static constexpr char const * const name{"EncBaseId"};
38342 static constexpr char const * const typestr{"uint32_t"};
38343 static constexpr bool traverse{false};
38344 static constexpr auto mbr_ptr{&SgAsmCilModule::p_EncBaseId};
38345 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38346 using bind = Desc<SgAsmCilModule, uint32_t SgAsmCilModule::*, &SgAsmCilModule::p_EncBaseId>;
38347};
38357template <> struct node_from_variant_t<980> { using type = SgAsmCilModule; };
38358
38359// Class: AsmCilModuleRef
38360template <> struct describe_field_t<SgAsmCilModuleRef,uint32_t,&SgAsmCilModuleRef::p_Name> {
38361 using parent = SgAsmCilModuleRef;
38362 using field_type = uint32_t;
38363 static constexpr size_t position{0};
38364 static constexpr char const * const name{"Name"};
38365 static constexpr char const * const typestr{"uint32_t"};
38366 static constexpr bool traverse{false};
38367 static constexpr auto mbr_ptr{&SgAsmCilModuleRef::p_Name};
38368 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38369 using bind = Desc<SgAsmCilModuleRef, uint32_t SgAsmCilModuleRef::*, &SgAsmCilModuleRef::p_Name>;
38370};
38372 using node = SgAsmCilModuleRef;
38373 using base = SgAsmCilMetadata;
38374 static constexpr char const * const name{"AsmCilModuleRef"};
38375 static constexpr unsigned long variant{981};
38376 static constexpr bool concrete{true};
38377 using subclasses_t = mp::List<>;
38379};
38380template <> struct node_from_variant_t<981> { using type = SgAsmCilModuleRef; };
38381
38382// Class: AsmCilNestedClass
38383template <> struct describe_field_t<SgAsmCilNestedClass,uint32_t,&SgAsmCilNestedClass::p_NestedClass> {
38385 using field_type = uint32_t;
38386 static constexpr size_t position{0};
38387 static constexpr char const * const name{"NestedClass"};
38388 static constexpr char const * const typestr{"uint32_t"};
38389 static constexpr bool traverse{false};
38390 static constexpr auto mbr_ptr{&SgAsmCilNestedClass::p_NestedClass};
38391 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38392 using bind = Desc<SgAsmCilNestedClass, uint32_t SgAsmCilNestedClass::*, &SgAsmCilNestedClass::p_NestedClass>;
38393};
38394template <> struct describe_field_t<SgAsmCilNestedClass,uint32_t,&SgAsmCilNestedClass::p_EnclosingClass> {
38396 using field_type = uint32_t;
38397 static constexpr size_t position{1};
38398 static constexpr char const * const name{"EnclosingClass"};
38399 static constexpr char const * const typestr{"uint32_t"};
38400 static constexpr bool traverse{false};
38401 static constexpr auto mbr_ptr{&SgAsmCilNestedClass::p_EnclosingClass};
38402 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38403 using bind = Desc<SgAsmCilNestedClass, uint32_t SgAsmCilNestedClass::*, &SgAsmCilNestedClass::p_EnclosingClass>;
38404};
38406 using node = SgAsmCilNestedClass;
38407 using base = SgAsmCilMetadata;
38408 static constexpr char const * const name{"AsmCilNestedClass"};
38409 static constexpr unsigned long variant{982};
38410 static constexpr bool concrete{true};
38411 using subclasses_t = mp::List<>;
38413};
38414template <> struct node_from_variant_t<982> { using type = SgAsmCilNestedClass; };
38415
38416// Class: AsmCilParam
38417template <> struct describe_field_t<SgAsmCilParam,uint16_t,&SgAsmCilParam::p_Flags> {
38418 using parent = SgAsmCilParam;
38419 using field_type = uint16_t;
38420 static constexpr size_t position{0};
38421 static constexpr char const * const name{"Flags"};
38422 static constexpr char const * const typestr{"uint16_t"};
38423 static constexpr bool traverse{false};
38424 static constexpr auto mbr_ptr{&SgAsmCilParam::p_Flags};
38425 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38426 using bind = Desc<SgAsmCilParam, uint16_t SgAsmCilParam::*, &SgAsmCilParam::p_Flags>;
38427};
38428template <> struct describe_field_t<SgAsmCilParam,uint16_t,&SgAsmCilParam::p_Sequence> {
38429 using parent = SgAsmCilParam;
38430 using field_type = uint16_t;
38431 static constexpr size_t position{1};
38432 static constexpr char const * const name{"Sequence"};
38433 static constexpr char const * const typestr{"uint16_t"};
38434 static constexpr bool traverse{false};
38435 static constexpr auto mbr_ptr{&SgAsmCilParam::p_Sequence};
38436 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38437 using bind = Desc<SgAsmCilParam, uint16_t SgAsmCilParam::*, &SgAsmCilParam::p_Sequence>;
38438};
38439template <> struct describe_field_t<SgAsmCilParam,uint32_t,&SgAsmCilParam::p_Name> {
38440 using parent = SgAsmCilParam;
38441 using field_type = uint32_t;
38442 static constexpr size_t position{2};
38443 static constexpr char const * const name{"Name"};
38444 static constexpr char const * const typestr{"uint32_t"};
38445 static constexpr bool traverse{false};
38446 static constexpr auto mbr_ptr{&SgAsmCilParam::p_Name};
38447 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38448 using bind = Desc<SgAsmCilParam, uint32_t SgAsmCilParam::*, &SgAsmCilParam::p_Name>;
38449};
38450template <> struct describe_node_t<SgAsmCilParam> {
38451 using node = SgAsmCilParam;
38452 using base = SgAsmCilMetadata;
38453 static constexpr char const * const name{"AsmCilParam"};
38454 static constexpr unsigned long variant{983};
38455 static constexpr bool concrete{true};
38456 using subclasses_t = mp::List<>;
38458};
38459template <> struct node_from_variant_t<983> { using type = SgAsmCilParam; };
38460
38461// Class: AsmCilProperty
38462template <> struct describe_field_t<SgAsmCilProperty,uint16_t,&SgAsmCilProperty::p_Flags> {
38463 using parent = SgAsmCilProperty;
38464 using field_type = uint16_t;
38465 static constexpr size_t position{0};
38466 static constexpr char const * const name{"Flags"};
38467 static constexpr char const * const typestr{"uint16_t"};
38468 static constexpr bool traverse{false};
38469 static constexpr auto mbr_ptr{&SgAsmCilProperty::p_Flags};
38470 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38471 using bind = Desc<SgAsmCilProperty, uint16_t SgAsmCilProperty::*, &SgAsmCilProperty::p_Flags>;
38472};
38473template <> struct describe_field_t<SgAsmCilProperty,uint32_t,&SgAsmCilProperty::p_Name> {
38474 using parent = SgAsmCilProperty;
38475 using field_type = uint32_t;
38476 static constexpr size_t position{1};
38477 static constexpr char const * const name{"Name"};
38478 static constexpr char const * const typestr{"uint32_t"};
38479 static constexpr bool traverse{false};
38480 static constexpr auto mbr_ptr{&SgAsmCilProperty::p_Name};
38481 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38482 using bind = Desc<SgAsmCilProperty, uint32_t SgAsmCilProperty::*, &SgAsmCilProperty::p_Name>;
38483};
38484template <> struct describe_field_t<SgAsmCilProperty,uint32_t,&SgAsmCilProperty::p_Type> {
38485 using parent = SgAsmCilProperty;
38486 using field_type = uint32_t;
38487 static constexpr size_t position{2};
38488 static constexpr char const * const name{"Type"};
38489 static constexpr char const * const typestr{"uint32_t"};
38490 static constexpr bool traverse{false};
38491 static constexpr auto mbr_ptr{&SgAsmCilProperty::p_Type};
38492 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38493 using bind = Desc<SgAsmCilProperty, uint32_t SgAsmCilProperty::*, &SgAsmCilProperty::p_Type>;
38494};
38496 using node = SgAsmCilProperty;
38497 using base = SgAsmCilMetadata;
38498 static constexpr char const * const name{"AsmCilProperty"};
38499 static constexpr unsigned long variant{984};
38500 static constexpr bool concrete{true};
38501 using subclasses_t = mp::List<>;
38503};
38504template <> struct node_from_variant_t<984> { using type = SgAsmCilProperty; };
38505
38506// Class: AsmCilPropertyMap
38507template <> struct describe_field_t<SgAsmCilPropertyMap,uint32_t,&SgAsmCilPropertyMap::p_Parent> {
38509 using field_type = uint32_t;
38510 static constexpr size_t position{0};
38511 static constexpr char const * const name{"Parent"};
38512 static constexpr char const * const typestr{"uint32_t"};
38513 static constexpr bool traverse{false};
38514 static constexpr auto mbr_ptr{&SgAsmCilPropertyMap::p_Parent};
38515 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38516 using bind = Desc<SgAsmCilPropertyMap, uint32_t SgAsmCilPropertyMap::*, &SgAsmCilPropertyMap::p_Parent>;
38517};
38518template <> struct describe_field_t<SgAsmCilPropertyMap,uint32_t,&SgAsmCilPropertyMap::p_PropertyList> {
38520 using field_type = uint32_t;
38521 static constexpr size_t position{1};
38522 static constexpr char const * const name{"PropertyList"};
38523 static constexpr char const * const typestr{"uint32_t"};
38524 static constexpr bool traverse{false};
38525 static constexpr auto mbr_ptr{&SgAsmCilPropertyMap::p_PropertyList};
38526 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38527 using bind = Desc<SgAsmCilPropertyMap, uint32_t SgAsmCilPropertyMap::*, &SgAsmCilPropertyMap::p_PropertyList>;
38528};
38530 using node = SgAsmCilPropertyMap;
38531 using base = SgAsmCilMetadata;
38532 static constexpr char const * const name{"AsmCilPropertyMap"};
38533 static constexpr unsigned long variant{985};
38534 static constexpr bool concrete{true};
38535 using subclasses_t = mp::List<>;
38537};
38538template <> struct node_from_variant_t<985> { using type = SgAsmCilPropertyMap; };
38539
38540// Class: AsmCilStandAloneSig
38541template <> struct describe_field_t<SgAsmCilStandAloneSig,uint32_t,&SgAsmCilStandAloneSig::p_Signature> {
38543 using field_type = uint32_t;
38544 static constexpr size_t position{0};
38545 static constexpr char const * const name{"Signature"};
38546 static constexpr char const * const typestr{"uint32_t"};
38547 static constexpr bool traverse{false};
38548 static constexpr auto mbr_ptr{&SgAsmCilStandAloneSig::p_Signature};
38549 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38550 using bind = Desc<SgAsmCilStandAloneSig, uint32_t SgAsmCilStandAloneSig::*, &SgAsmCilStandAloneSig::p_Signature>;
38551};
38554 using base = SgAsmCilMetadata;
38555 static constexpr char const * const name{"AsmCilStandAloneSig"};
38556 static constexpr unsigned long variant{986};
38557 static constexpr bool concrete{true};
38558 using subclasses_t = mp::List<>;
38560};
38561template <> struct node_from_variant_t<986> { using type = SgAsmCilStandAloneSig; };
38562
38563// Class: AsmCilTypeDef
38564template <> struct describe_field_t<SgAsmCilTypeDef,uint32_t,&SgAsmCilTypeDef::p_Flags> {
38565 using parent = SgAsmCilTypeDef;
38566 using field_type = uint32_t;
38567 static constexpr size_t position{0};
38568 static constexpr char const * const name{"Flags"};
38569 static constexpr char const * const typestr{"uint32_t"};
38570 static constexpr bool traverse{false};
38571 static constexpr auto mbr_ptr{&SgAsmCilTypeDef::p_Flags};
38572 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38573 using bind = Desc<SgAsmCilTypeDef, uint32_t SgAsmCilTypeDef::*, &SgAsmCilTypeDef::p_Flags>;
38574};
38575template <> struct describe_field_t<SgAsmCilTypeDef,uint32_t,&SgAsmCilTypeDef::p_TypeName> {
38576 using parent = SgAsmCilTypeDef;
38577 using field_type = uint32_t;
38578 static constexpr size_t position{1};
38579 static constexpr char const * const name{"TypeName"};
38580 static constexpr char const * const typestr{"uint32_t"};
38581 static constexpr bool traverse{false};
38582 static constexpr auto mbr_ptr{&SgAsmCilTypeDef::p_TypeName};
38583 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38584 using bind = Desc<SgAsmCilTypeDef, uint32_t SgAsmCilTypeDef::*, &SgAsmCilTypeDef::p_TypeName>;
38585};
38586template <> struct describe_field_t<SgAsmCilTypeDef,uint32_t,&SgAsmCilTypeDef::p_TypeNamespace> {
38587 using parent = SgAsmCilTypeDef;
38588 using field_type = uint32_t;
38589 static constexpr size_t position{2};
38590 static constexpr char const * const name{"TypeNamespace"};
38591 static constexpr char const * const typestr{"uint32_t"};
38592 static constexpr bool traverse{false};
38593 static constexpr auto mbr_ptr{&SgAsmCilTypeDef::p_TypeNamespace};
38594 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38595 using bind = Desc<SgAsmCilTypeDef, uint32_t SgAsmCilTypeDef::*, &SgAsmCilTypeDef::p_TypeNamespace>;
38596};
38597template <> struct describe_field_t<SgAsmCilTypeDef,uint32_t,&SgAsmCilTypeDef::p_Extends> {
38598 using parent = SgAsmCilTypeDef;
38599 using field_type = uint32_t;
38600 static constexpr size_t position{3};
38601 static constexpr char const * const name{"Extends"};
38602 static constexpr char const * const typestr{"uint32_t"};
38603 static constexpr bool traverse{false};
38604 static constexpr auto mbr_ptr{&SgAsmCilTypeDef::p_Extends};
38605 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38606 using bind = Desc<SgAsmCilTypeDef, uint32_t SgAsmCilTypeDef::*, &SgAsmCilTypeDef::p_Extends>;
38607};
38608template <> struct describe_field_t<SgAsmCilTypeDef,uint32_t,&SgAsmCilTypeDef::p_FieldList> {
38609 using parent = SgAsmCilTypeDef;
38610 using field_type = uint32_t;
38611 static constexpr size_t position{4};
38612 static constexpr char const * const name{"FieldList"};
38613 static constexpr char const * const typestr{"uint32_t"};
38614 static constexpr bool traverse{false};
38615 static constexpr auto mbr_ptr{&SgAsmCilTypeDef::p_FieldList};
38616 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38617 using bind = Desc<SgAsmCilTypeDef, uint32_t SgAsmCilTypeDef::*, &SgAsmCilTypeDef::p_FieldList>;
38618};
38619template <> struct describe_field_t<SgAsmCilTypeDef,uint32_t,&SgAsmCilTypeDef::p_MethodList> {
38620 using parent = SgAsmCilTypeDef;
38621 using field_type = uint32_t;
38622 static constexpr size_t position{5};
38623 static constexpr char const * const name{"MethodList"};
38624 static constexpr char const * const typestr{"uint32_t"};
38625 static constexpr bool traverse{false};
38626 static constexpr auto mbr_ptr{&SgAsmCilTypeDef::p_MethodList};
38627 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38628 using bind = Desc<SgAsmCilTypeDef, uint32_t SgAsmCilTypeDef::*, &SgAsmCilTypeDef::p_MethodList>;
38629};
38639template <> struct node_from_variant_t<987> { using type = SgAsmCilTypeDef; };
38640
38641// Class: AsmCilTypeRef
38642template <> struct describe_field_t<SgAsmCilTypeRef,uint16_t,&SgAsmCilTypeRef::p_ResolutionScope> {
38643 using parent = SgAsmCilTypeRef;
38644 using field_type = uint16_t;
38645 static constexpr size_t position{0};
38646 static constexpr char const * const name{"ResolutionScope"};
38647 static constexpr char const * const typestr{"uint16_t"};
38648 static constexpr bool traverse{false};
38649 static constexpr auto mbr_ptr{&SgAsmCilTypeRef::p_ResolutionScope};
38650 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38651 using bind = Desc<SgAsmCilTypeRef, uint16_t SgAsmCilTypeRef::*, &SgAsmCilTypeRef::p_ResolutionScope>;
38652};
38653template <> struct describe_field_t<SgAsmCilTypeRef,uint32_t,&SgAsmCilTypeRef::p_TypeName> {
38654 using parent = SgAsmCilTypeRef;
38655 using field_type = uint32_t;
38656 static constexpr size_t position{1};
38657 static constexpr char const * const name{"TypeName"};
38658 static constexpr char const * const typestr{"uint32_t"};
38659 static constexpr bool traverse{false};
38660 static constexpr auto mbr_ptr{&SgAsmCilTypeRef::p_TypeName};
38661 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38662 using bind = Desc<SgAsmCilTypeRef, uint32_t SgAsmCilTypeRef::*, &SgAsmCilTypeRef::p_TypeName>;
38663};
38664template <> struct describe_field_t<SgAsmCilTypeRef,uint32_t,&SgAsmCilTypeRef::p_TypeNamespace> {
38665 using parent = SgAsmCilTypeRef;
38666 using field_type = uint32_t;
38667 static constexpr size_t position{2};
38668 static constexpr char const * const name{"TypeNamespace"};
38669 static constexpr char const * const typestr{"uint32_t"};
38670 static constexpr bool traverse{false};
38671 static constexpr auto mbr_ptr{&SgAsmCilTypeRef::p_TypeNamespace};
38672 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38673 using bind = Desc<SgAsmCilTypeRef, uint32_t SgAsmCilTypeRef::*, &SgAsmCilTypeRef::p_TypeNamespace>;
38674};
38676 using node = SgAsmCilTypeRef;
38677 using base = SgAsmCilMetadata;
38678 static constexpr char const * const name{"AsmCilTypeRef"};
38679 static constexpr unsigned long variant{988};
38680 static constexpr bool concrete{true};
38681 using subclasses_t = mp::List<>;
38683};
38684template <> struct node_from_variant_t<988> { using type = SgAsmCilTypeRef; };
38685
38686// Class: AsmCilTypeSpec
38687template <> struct describe_field_t<SgAsmCilTypeSpec,uint32_t,&SgAsmCilTypeSpec::p_Signature> {
38688 using parent = SgAsmCilTypeSpec;
38689 using field_type = uint32_t;
38690 static constexpr size_t position{0};
38691 static constexpr char const * const name{"Signature"};
38692 static constexpr char const * const typestr{"uint32_t"};
38693 static constexpr bool traverse{false};
38694 static constexpr auto mbr_ptr{&SgAsmCilTypeSpec::p_Signature};
38695 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38696 using bind = Desc<SgAsmCilTypeSpec, uint32_t SgAsmCilTypeSpec::*, &SgAsmCilTypeSpec::p_Signature>;
38697};
38699 using node = SgAsmCilTypeSpec;
38700 using base = SgAsmCilMetadata;
38701 static constexpr char const * const name{"AsmCilTypeSpec"};
38702 static constexpr unsigned long variant{989};
38703 static constexpr bool concrete{true};
38704 using subclasses_t = mp::List<>;
38706};
38707template <> struct node_from_variant_t<989> { using type = SgAsmCilTypeSpec; };
38708
38709// Class: AdaParameterList
38710template <> struct describe_field_t<SgAdaParameterList,SgDeclarationStatementPtrList,&SgAdaParameterList::p_parameters> {
38711 using parent = SgAdaParameterList;
38712 using field_type = SgDeclarationStatementPtrList;
38713 static constexpr size_t position{0};
38714 static constexpr char const * const name{"parameters"};
38715 static constexpr char const * const typestr{"SgDeclarationStatementPtrList"};
38716 static constexpr bool traverse{true};
38717 static constexpr auto mbr_ptr{&SgAdaParameterList::p_parameters};
38718 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38719 using bind = Desc<SgAdaParameterList, SgDeclarationStatementPtrList SgAdaParameterList::*, &SgAdaParameterList::p_parameters>;
38720};
38722 using node = SgAdaParameterList;
38724 static constexpr char const * const name{"AdaParameterList"};
38725 static constexpr unsigned long variant{990};
38726 static constexpr bool concrete{true};
38727 using subclasses_t = mp::List<>;
38729};
38730template <> struct node_from_variant_t<990> { using type = SgAdaParameterList; };
38731
38732// Class: AsmCilMetadata
38734 using node = SgAsmCilMetadata;
38735 using base = SgAsmCilNode;
38736 static constexpr char const * const name{"AsmCilMetadata"};
38737 static constexpr unsigned long variant{991};
38738 static constexpr bool concrete{false};
38739 using subclasses_t = mp::List<SgAsmCilAssembly, SgAsmCilAssemblyOS, SgAsmCilAssemblyOSTable, SgAsmCilAssemblyProcessor, SgAsmCilAssemblyProcessorTable, SgAsmCilAssemblyRef, SgAsmCilAssemblyRefOS, SgAsmCilAssemblyRefOSTable, SgAsmCilAssemblyRefProcessor, SgAsmCilAssemblyRefProcessorTable, SgAsmCilAssemblyRefTable, SgAsmCilAssemblyTable, SgAsmCilClassLayout, SgAsmCilClassLayoutTable, SgAsmCilConstant, SgAsmCilConstantTable, SgAsmCilCustomAttribute, SgAsmCilCustomAttributeTable, SgAsmCilDeclSecurity, SgAsmCilDeclSecurityTable, SgAsmCilEvent, SgAsmCilEventMap, SgAsmCilEventMapTable, SgAsmCilEventTable, SgAsmCilExportedType, SgAsmCilExportedTypeTable, SgAsmCilField, SgAsmCilFieldLayout, SgAsmCilFieldLayoutTable, SgAsmCilFieldMarshal, SgAsmCilFieldMarshalTable, SgAsmCilFieldRVA, SgAsmCilFieldRVATable, SgAsmCilFieldTable, SgAsmCilFile, SgAsmCilFileTable, SgAsmCilGenericParamConstraint, SgAsmCilGenericParamConstraintTable, SgAsmCilGenericParam, SgAsmCilGenericParamTable, SgAsmCilImplMap, SgAsmCilImplMapTable, SgAsmCilInterfaceImpl, SgAsmCilInterfaceImplTable, SgAsmCilManifestResource, SgAsmCilManifestResourceTable, SgAsmCilMemberRef, SgAsmCilMemberRefTable, SgAsmCilMethodDef, SgAsmCilMethodDefTable, SgAsmCilMethodImpl, SgAsmCilMethodImplTable, SgAsmCilMethodSemantics, SgAsmCilMethodSemanticsTable, SgAsmCilMethodSpec, SgAsmCilMethodSpecTable, SgAsmCilModule, SgAsmCilModuleRef, SgAsmCilModuleRefTable, SgAsmCilModuleTable, SgAsmCilNestedClass, SgAsmCilNestedClassTable, SgAsmCilParam, SgAsmCilParamTable, SgAsmCilProperty, SgAsmCilPropertyMap, SgAsmCilPropertyMapTable, SgAsmCilPropertyTable, SgAsmCilStandAloneSig, SgAsmCilStandAloneSigTable, SgAsmCilTypeDef, SgAsmCilTypeDefTable, SgAsmCilTypeRef, SgAsmCilTypeRefTable, SgAsmCilTypeSpec, SgAsmCilTypeSpecTable>;
38740 using fields_t = mp::List<>;
38741};
38742template <> struct node_from_variant_t<991> { using type = SgAsmCilMetadata; };
38743
38744// Class: AsmCilMetadataRoot
38745template <> struct describe_field_t<SgAsmCilMetadataRoot,uint32_t,&SgAsmCilMetadataRoot::p_Signature> {
38747 using field_type = uint32_t;
38748 static constexpr size_t position{0};
38749 static constexpr char const * const name{"Signature"};
38750 static constexpr char const * const typestr{"uint32_t"};
38751 static constexpr bool traverse{false};
38752 static constexpr auto mbr_ptr{&SgAsmCilMetadataRoot::p_Signature};
38753 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38754 using bind = Desc<SgAsmCilMetadataRoot, uint32_t SgAsmCilMetadataRoot::*, &SgAsmCilMetadataRoot::p_Signature>;
38755};
38756template <> struct describe_field_t<SgAsmCilMetadataRoot,uint16_t,&SgAsmCilMetadataRoot::p_MajorVersion> {
38758 using field_type = uint16_t;
38759 static constexpr size_t position{1};
38760 static constexpr char const * const name{"MajorVersion"};
38761 static constexpr char const * const typestr{"uint16_t"};
38762 static constexpr bool traverse{false};
38763 static constexpr auto mbr_ptr{&SgAsmCilMetadataRoot::p_MajorVersion};
38764 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38765 using bind = Desc<SgAsmCilMetadataRoot, uint16_t SgAsmCilMetadataRoot::*, &SgAsmCilMetadataRoot::p_MajorVersion>;
38766};
38767template <> struct describe_field_t<SgAsmCilMetadataRoot,uint16_t,&SgAsmCilMetadataRoot::p_MinorVersion> {
38769 using field_type = uint16_t;
38770 static constexpr size_t position{2};
38771 static constexpr char const * const name{"MinorVersion"};
38772 static constexpr char const * const typestr{"uint16_t"};
38773 static constexpr bool traverse{false};
38774 static constexpr auto mbr_ptr{&SgAsmCilMetadataRoot::p_MinorVersion};
38775 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38776 using bind = Desc<SgAsmCilMetadataRoot, uint16_t SgAsmCilMetadataRoot::*, &SgAsmCilMetadataRoot::p_MinorVersion>;
38777};
38778template <> struct describe_field_t<SgAsmCilMetadataRoot,uint32_t,&SgAsmCilMetadataRoot::p_Reserved0> {
38780 using field_type = uint32_t;
38781 static constexpr size_t position{3};
38782 static constexpr char const * const name{"Reserved0"};
38783 static constexpr char const * const typestr{"uint32_t"};
38784 static constexpr bool traverse{false};
38785 static constexpr auto mbr_ptr{&SgAsmCilMetadataRoot::p_Reserved0};
38786 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38787 using bind = Desc<SgAsmCilMetadataRoot, uint32_t SgAsmCilMetadataRoot::*, &SgAsmCilMetadataRoot::p_Reserved0>;
38788};
38789template <> struct describe_field_t<SgAsmCilMetadataRoot,uint32_t,&SgAsmCilMetadataRoot::p_Length> {
38791 using field_type = uint32_t;
38792 static constexpr size_t position{4};
38793 static constexpr char const * const name{"Length"};
38794 static constexpr char const * const typestr{"uint32_t"};
38795 static constexpr bool traverse{false};
38796 static constexpr auto mbr_ptr{&SgAsmCilMetadataRoot::p_Length};
38797 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38798 using bind = Desc<SgAsmCilMetadataRoot, uint32_t SgAsmCilMetadataRoot::*, &SgAsmCilMetadataRoot::p_Length>;
38799};
38800template <> struct describe_field_t<SgAsmCilMetadataRoot,std::string,&SgAsmCilMetadataRoot::p_Version> {
38802 using field_type = std::string;
38803 static constexpr size_t position{5};
38804 static constexpr char const * const name{"Version"};
38805 static constexpr char const * const typestr{"std::string"};
38806 static constexpr bool traverse{false};
38807 static constexpr auto mbr_ptr{&SgAsmCilMetadataRoot::p_Version};
38808 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38809 using bind = Desc<SgAsmCilMetadataRoot, std::string SgAsmCilMetadataRoot::*, &SgAsmCilMetadataRoot::p_Version>;
38810};
38811template <> struct describe_field_t<SgAsmCilMetadataRoot,uint32_t,&SgAsmCilMetadataRoot::p_VersionPadding> {
38813 using field_type = uint32_t;
38814 static constexpr size_t position{6};
38815 static constexpr char const * const name{"VersionPadding"};
38816 static constexpr char const * const typestr{"uint32_t"};
38817 static constexpr bool traverse{false};
38818 static constexpr auto mbr_ptr{&SgAsmCilMetadataRoot::p_VersionPadding};
38819 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38820 using bind = Desc<SgAsmCilMetadataRoot, uint32_t SgAsmCilMetadataRoot::*, &SgAsmCilMetadataRoot::p_VersionPadding>;
38821};
38822template <> struct describe_field_t<SgAsmCilMetadataRoot,uint16_t,&SgAsmCilMetadataRoot::p_Flags> {
38824 using field_type = uint16_t;
38825 static constexpr size_t position{7};
38826 static constexpr char const * const name{"Flags"};
38827 static constexpr char const * const typestr{"uint16_t"};
38828 static constexpr bool traverse{false};
38829 static constexpr auto mbr_ptr{&SgAsmCilMetadataRoot::p_Flags};
38830 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38831 using bind = Desc<SgAsmCilMetadataRoot, uint16_t SgAsmCilMetadataRoot::*, &SgAsmCilMetadataRoot::p_Flags>;
38832};
38833template <> struct describe_field_t<SgAsmCilMetadataRoot,uint16_t,&SgAsmCilMetadataRoot::p_NumberOfStreams> {
38835 using field_type = uint16_t;
38836 static constexpr size_t position{8};
38837 static constexpr char const * const name{"NumberOfStreams"};
38838 static constexpr char const * const typestr{"uint16_t"};
38839 static constexpr bool traverse{false};
38840 static constexpr auto mbr_ptr{&SgAsmCilMetadataRoot::p_NumberOfStreams};
38841 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38842 using bind = Desc<SgAsmCilMetadataRoot, uint16_t SgAsmCilMetadataRoot::*, &SgAsmCilMetadataRoot::p_NumberOfStreams>;
38843};
38844template <> struct describe_field_t<SgAsmCilMetadataRoot,std::vector<SgAsmCilDataStream*>,&SgAsmCilMetadataRoot::p_Streams> {
38846 using field_type = std::vector<SgAsmCilDataStream*>;
38847 static constexpr size_t position{9};
38848 static constexpr char const * const name{"Streams"};
38849 static constexpr char const * const typestr{"std::vector<SgAsmCilDataStream*>"};
38850 static constexpr bool traverse{true};
38851 static constexpr auto mbr_ptr{&SgAsmCilMetadataRoot::p_Streams};
38852 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38853 using bind = Desc<SgAsmCilMetadataRoot, std::vector<SgAsmCilDataStream*> SgAsmCilMetadataRoot::*, &SgAsmCilMetadataRoot::p_Streams>;
38854};
38864template <> struct node_from_variant_t<992> { using type = SgAsmCilMetadataRoot; };
38865
38866// Class: AsmCilDataStream
38867template <> struct describe_field_t<SgAsmCilDataStream,uint32_t,&SgAsmCilDataStream::p_Offset> {
38868 using parent = SgAsmCilDataStream;
38869 using field_type = uint32_t;
38870 static constexpr size_t position{0};
38871 static constexpr char const * const name{"Offset"};
38872 static constexpr char const * const typestr{"uint32_t"};
38873 static constexpr bool traverse{false};
38874 static constexpr auto mbr_ptr{&SgAsmCilDataStream::p_Offset};
38875 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38876 using bind = Desc<SgAsmCilDataStream, uint32_t SgAsmCilDataStream::*, &SgAsmCilDataStream::p_Offset>;
38877};
38878template <> struct describe_field_t<SgAsmCilDataStream,uint32_t,&SgAsmCilDataStream::p_Size> {
38879 using parent = SgAsmCilDataStream;
38880 using field_type = uint32_t;
38881 static constexpr size_t position{1};
38882 static constexpr char const * const name{"Size"};
38883 static constexpr char const * const typestr{"uint32_t"};
38884 static constexpr bool traverse{false};
38885 static constexpr auto mbr_ptr{&SgAsmCilDataStream::p_Size};
38886 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38887 using bind = Desc<SgAsmCilDataStream, uint32_t SgAsmCilDataStream::*, &SgAsmCilDataStream::p_Size>;
38888};
38889template <> struct describe_field_t<SgAsmCilDataStream,std::string,&SgAsmCilDataStream::p_Name> {
38890 using parent = SgAsmCilDataStream;
38891 using field_type = std::string;
38892 static constexpr size_t position{2};
38893 static constexpr char const * const name{"Name"};
38894 static constexpr char const * const typestr{"std::string"};
38895 static constexpr bool traverse{false};
38896 static constexpr auto mbr_ptr{&SgAsmCilDataStream::p_Name};
38897 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38898 using bind = Desc<SgAsmCilDataStream, std::string SgAsmCilDataStream::*, &SgAsmCilDataStream::p_Name>;
38899};
38900template <> struct describe_field_t<SgAsmCilDataStream,uint32_t,&SgAsmCilDataStream::p_NamePadding> {
38901 using parent = SgAsmCilDataStream;
38902 using field_type = uint32_t;
38903 static constexpr size_t position{3};
38904 static constexpr char const * const name{"NamePadding"};
38905 static constexpr char const * const typestr{"uint32_t"};
38906 static constexpr bool traverse{false};
38907 static constexpr auto mbr_ptr{&SgAsmCilDataStream::p_NamePadding};
38908 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38909 using bind = Desc<SgAsmCilDataStream, uint32_t SgAsmCilDataStream::*, &SgAsmCilDataStream::p_NamePadding>;
38910};
38920template <> struct node_from_variant_t<993> { using type = SgAsmCilDataStream; };
38921
38922// Class: AsmCilMetadataHeap
38923template <> struct describe_field_t<SgAsmCilMetadataHeap,uint32_t,&SgAsmCilMetadataHeap::p_ReservedAlwaysZero> {
38925 using field_type = uint32_t;
38926 static constexpr size_t position{0};
38927 static constexpr char const * const name{"ReservedAlwaysZero"};
38928 static constexpr char const * const typestr{"uint32_t"};
38929 static constexpr bool traverse{false};
38930 static constexpr auto mbr_ptr{&SgAsmCilMetadataHeap::p_ReservedAlwaysZero};
38931 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38932 using bind = Desc<SgAsmCilMetadataHeap, uint32_t SgAsmCilMetadataHeap::*, &SgAsmCilMetadataHeap::p_ReservedAlwaysZero>;
38933};
38934template <> struct describe_field_t<SgAsmCilMetadataHeap,uint8_t,&SgAsmCilMetadataHeap::p_MajorVersion> {
38936 using field_type = uint8_t;
38937 static constexpr size_t position{1};
38938 static constexpr char const * const name{"MajorVersion"};
38939 static constexpr char const * const typestr{"uint8_t"};
38940 static constexpr bool traverse{false};
38941 static constexpr auto mbr_ptr{&SgAsmCilMetadataHeap::p_MajorVersion};
38942 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38943 using bind = Desc<SgAsmCilMetadataHeap, uint8_t SgAsmCilMetadataHeap::*, &SgAsmCilMetadataHeap::p_MajorVersion>;
38944};
38945template <> struct describe_field_t<SgAsmCilMetadataHeap,uint8_t,&SgAsmCilMetadataHeap::p_MinorVersion> {
38947 using field_type = uint8_t;
38948 static constexpr size_t position{2};
38949 static constexpr char const * const name{"MinorVersion"};
38950 static constexpr char const * const typestr{"uint8_t"};
38951 static constexpr bool traverse{false};
38952 static constexpr auto mbr_ptr{&SgAsmCilMetadataHeap::p_MinorVersion};
38953 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38954 using bind = Desc<SgAsmCilMetadataHeap, uint8_t SgAsmCilMetadataHeap::*, &SgAsmCilMetadataHeap::p_MinorVersion>;
38955};
38956template <> struct describe_field_t<SgAsmCilMetadataHeap,uint8_t,&SgAsmCilMetadataHeap::p_HeapSizes> {
38958 using field_type = uint8_t;
38959 static constexpr size_t position{3};
38960 static constexpr char const * const name{"HeapSizes"};
38961 static constexpr char const * const typestr{"uint8_t"};
38962 static constexpr bool traverse{false};
38963 static constexpr auto mbr_ptr{&SgAsmCilMetadataHeap::p_HeapSizes};
38964 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38965 using bind = Desc<SgAsmCilMetadataHeap, uint8_t SgAsmCilMetadataHeap::*, &SgAsmCilMetadataHeap::p_HeapSizes>;
38966};
38967template <> struct describe_field_t<SgAsmCilMetadataHeap,uint8_t,&SgAsmCilMetadataHeap::p_ReservedAlwaysOne> {
38969 using field_type = uint8_t;
38970 static constexpr size_t position{4};
38971 static constexpr char const * const name{"ReservedAlwaysOne"};
38972 static constexpr char const * const typestr{"uint8_t"};
38973 static constexpr bool traverse{false};
38974 static constexpr auto mbr_ptr{&SgAsmCilMetadataHeap::p_ReservedAlwaysOne};
38975 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38976 using bind = Desc<SgAsmCilMetadataHeap, uint8_t SgAsmCilMetadataHeap::*, &SgAsmCilMetadataHeap::p_ReservedAlwaysOne>;
38977};
38978template <> struct describe_field_t<SgAsmCilMetadataHeap,uint64_t,&SgAsmCilMetadataHeap::p_Valid> {
38980 using field_type = uint64_t;
38981 static constexpr size_t position{5};
38982 static constexpr char const * const name{"Valid"};
38983 static constexpr char const * const typestr{"uint64_t"};
38984 static constexpr bool traverse{false};
38985 static constexpr auto mbr_ptr{&SgAsmCilMetadataHeap::p_Valid};
38986 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38987 using bind = Desc<SgAsmCilMetadataHeap, uint64_t SgAsmCilMetadataHeap::*, &SgAsmCilMetadataHeap::p_Valid>;
38988};
38989template <> struct describe_field_t<SgAsmCilMetadataHeap,uint64_t,&SgAsmCilMetadataHeap::p_Sorted> {
38991 using field_type = uint64_t;
38992 static constexpr size_t position{6};
38993 static constexpr char const * const name{"Sorted"};
38994 static constexpr char const * const typestr{"uint64_t"};
38995 static constexpr bool traverse{false};
38996 static constexpr auto mbr_ptr{&SgAsmCilMetadataHeap::p_Sorted};
38997 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
38998 using bind = Desc<SgAsmCilMetadataHeap, uint64_t SgAsmCilMetadataHeap::*, &SgAsmCilMetadataHeap::p_Sorted>;
38999};
39000template <> struct describe_field_t<SgAsmCilMetadataHeap,std::vector<uint32_t>,&SgAsmCilMetadataHeap::p_NumberOfRows> {
39002 using field_type = std::vector<uint32_t>;
39003 static constexpr size_t position{7};
39004 static constexpr char const * const name{"NumberOfRows"};
39005 static constexpr char const * const typestr{"std::vector<uint32_t>"};
39006 static constexpr bool traverse{false};
39007 static constexpr auto mbr_ptr{&SgAsmCilMetadataHeap::p_NumberOfRows};
39008 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39009 using bind = Desc<SgAsmCilMetadataHeap, std::vector<uint32_t> SgAsmCilMetadataHeap::*, &SgAsmCilMetadataHeap::p_NumberOfRows>;
39010};
39011template <> struct describe_field_t<SgAsmCilMetadataHeap,uint64_t,&SgAsmCilMetadataHeap::p_DataSizeFlags> {
39013 using field_type = uint64_t;
39014 static constexpr size_t position{8};
39015 static constexpr char const * const name{"DataSizeFlags"};
39016 static constexpr char const * const typestr{"uint64_t"};
39017 static constexpr bool traverse{false};
39018 static constexpr auto mbr_ptr{&SgAsmCilMetadataHeap::p_DataSizeFlags};
39019 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39020 using bind = Desc<SgAsmCilMetadataHeap, uint64_t SgAsmCilMetadataHeap::*, &SgAsmCilMetadataHeap::p_DataSizeFlags>;
39021};
39022template <> struct describe_field_t<SgAsmCilMetadataHeap,SgAsmCilAssemblyTable*,&SgAsmCilMetadataHeap::p_AssemblyTable> {
39025 static constexpr size_t position{9};
39026 static constexpr char const * const name{"AssemblyTable"};
39027 static constexpr char const * const typestr{"SgAsmCilAssemblyTable*"};
39028 static constexpr bool traverse{true};
39029 static constexpr auto mbr_ptr{&SgAsmCilMetadataHeap::p_AssemblyTable};
39030 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39031 using bind = Desc<SgAsmCilMetadataHeap, SgAsmCilAssemblyTable* SgAsmCilMetadataHeap::*, &SgAsmCilMetadataHeap::p_AssemblyTable>;
39032};
39033template <> struct describe_field_t<SgAsmCilMetadataHeap,SgAsmCilAssemblyOSTable*,&SgAsmCilMetadataHeap::p_AssemblyOSTable> {
39036 static constexpr size_t position{10};
39037 static constexpr char const * const name{"AssemblyOSTable"};
39038 static constexpr char const * const typestr{"SgAsmCilAssemblyOSTable*"};
39039 static constexpr bool traverse{true};
39040 static constexpr auto mbr_ptr{&SgAsmCilMetadataHeap::p_AssemblyOSTable};
39041 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39042 using bind = Desc<SgAsmCilMetadataHeap, SgAsmCilAssemblyOSTable* SgAsmCilMetadataHeap::*, &SgAsmCilMetadataHeap::p_AssemblyOSTable>;
39043};
39044template <> struct describe_field_t<SgAsmCilMetadataHeap,SgAsmCilAssemblyProcessorTable*,&SgAsmCilMetadataHeap::p_AssemblyProcessorTable> {
39047 static constexpr size_t position{11};
39048 static constexpr char const * const name{"AssemblyProcessorTable"};
39049 static constexpr char const * const typestr{"SgAsmCilAssemblyProcessorTable*"};
39050 static constexpr bool traverse{true};
39051 static constexpr auto mbr_ptr{&SgAsmCilMetadataHeap::p_AssemblyProcessorTable};
39052 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39053 using bind = Desc<SgAsmCilMetadataHeap, SgAsmCilAssemblyProcessorTable* SgAsmCilMetadataHeap::*, &SgAsmCilMetadataHeap::p_AssemblyProcessorTable>;
39054};
39055template <> struct describe_field_t<SgAsmCilMetadataHeap,SgAsmCilAssemblyRefTable*,&SgAsmCilMetadataHeap::p_AssemblyRefTable> {
39058 static constexpr size_t position{12};
39059 static constexpr char const * const name{"AssemblyRefTable"};
39060 static constexpr char const * const typestr{"SgAsmCilAssemblyRefTable*"};
39061 static constexpr bool traverse{true};
39062 static constexpr auto mbr_ptr{&SgAsmCilMetadataHeap::p_AssemblyRefTable};
39063 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39064 using bind = Desc<SgAsmCilMetadataHeap, SgAsmCilAssemblyRefTable* SgAsmCilMetadataHeap::*, &SgAsmCilMetadataHeap::p_AssemblyRefTable>;
39065};
39066template <> struct describe_field_t<SgAsmCilMetadataHeap,SgAsmCilAssemblyRefOSTable*,&SgAsmCilMetadataHeap::p_AssemblyRefOSTable> {
39069 static constexpr size_t position{13};
39070 static constexpr char const * const name{"AssemblyRefOSTable"};
39071 static constexpr char const * const typestr{"SgAsmCilAssemblyRefOSTable*"};
39072 static constexpr bool traverse{true};
39073 static constexpr auto mbr_ptr{&SgAsmCilMetadataHeap::p_AssemblyRefOSTable};
39074 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39075 using bind = Desc<SgAsmCilMetadataHeap, SgAsmCilAssemblyRefOSTable* SgAsmCilMetadataHeap::*, &SgAsmCilMetadataHeap::p_AssemblyRefOSTable>;
39076};
39077template <> struct describe_field_t<SgAsmCilMetadataHeap,SgAsmCilAssemblyRefProcessorTable*,&SgAsmCilMetadataHeap::p_AssemblyRefProcessorTable> {
39080 static constexpr size_t position{14};
39081 static constexpr char const * const name{"AssemblyRefProcessorTable"};
39082 static constexpr char const * const typestr{"SgAsmCilAssemblyRefProcessorTable*"};
39083 static constexpr bool traverse{true};
39084 static constexpr auto mbr_ptr{&SgAsmCilMetadataHeap::p_AssemblyRefProcessorTable};
39085 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39086 using bind = Desc<SgAsmCilMetadataHeap, SgAsmCilAssemblyRefProcessorTable* SgAsmCilMetadataHeap::*, &SgAsmCilMetadataHeap::p_AssemblyRefProcessorTable>;
39087};
39088template <> struct describe_field_t<SgAsmCilMetadataHeap,SgAsmCilClassLayoutTable*,&SgAsmCilMetadataHeap::p_ClassLayoutTable> {
39091 static constexpr size_t position{15};
39092 static constexpr char const * const name{"ClassLayoutTable"};
39093 static constexpr char const * const typestr{"SgAsmCilClassLayoutTable*"};
39094 static constexpr bool traverse{true};
39095 static constexpr auto mbr_ptr{&SgAsmCilMetadataHeap::p_ClassLayoutTable};
39096 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39097 using bind = Desc<SgAsmCilMetadataHeap, SgAsmCilClassLayoutTable* SgAsmCilMetadataHeap::*, &SgAsmCilMetadataHeap::p_ClassLayoutTable>;
39098};
39099template <> struct describe_field_t<SgAsmCilMetadataHeap,SgAsmCilConstantTable*,&SgAsmCilMetadataHeap::p_ConstantTable> {
39102 static constexpr size_t position{16};
39103 static constexpr char const * const name{"ConstantTable"};
39104 static constexpr char const * const typestr{"SgAsmCilConstantTable*"};
39105 static constexpr bool traverse{true};
39106 static constexpr auto mbr_ptr{&SgAsmCilMetadataHeap::p_ConstantTable};
39107 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39108 using bind = Desc<SgAsmCilMetadataHeap, SgAsmCilConstantTable* SgAsmCilMetadataHeap::*, &SgAsmCilMetadataHeap::p_ConstantTable>;
39109};
39110template <> struct describe_field_t<SgAsmCilMetadataHeap,SgAsmCilCustomAttributeTable*,&SgAsmCilMetadataHeap::p_CustomAttributeTable> {
39113 static constexpr size_t position{17};
39114 static constexpr char const * const name{"CustomAttributeTable"};
39115 static constexpr char const * const typestr{"SgAsmCilCustomAttributeTable*"};
39116 static constexpr bool traverse{true};
39117 static constexpr auto mbr_ptr{&SgAsmCilMetadataHeap::p_CustomAttributeTable};
39118 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39119 using bind = Desc<SgAsmCilMetadataHeap, SgAsmCilCustomAttributeTable* SgAsmCilMetadataHeap::*, &SgAsmCilMetadataHeap::p_CustomAttributeTable>;
39120};
39121template <> struct describe_field_t<SgAsmCilMetadataHeap,SgAsmCilDeclSecurityTable*,&SgAsmCilMetadataHeap::p_DeclSecurityTable> {
39124 static constexpr size_t position{18};
39125 static constexpr char const * const name{"DeclSecurityTable"};
39126 static constexpr char const * const typestr{"SgAsmCilDeclSecurityTable*"};
39127 static constexpr bool traverse{true};
39128 static constexpr auto mbr_ptr{&SgAsmCilMetadataHeap::p_DeclSecurityTable};
39129 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39130 using bind = Desc<SgAsmCilMetadataHeap, SgAsmCilDeclSecurityTable* SgAsmCilMetadataHeap::*, &SgAsmCilMetadataHeap::p_DeclSecurityTable>;
39131};
39132template <> struct describe_field_t<SgAsmCilMetadataHeap,SgAsmCilEventTable*,&SgAsmCilMetadataHeap::p_EventTable> {
39135 static constexpr size_t position{19};
39136 static constexpr char const * const name{"EventTable"};
39137 static constexpr char const * const typestr{"SgAsmCilEventTable*"};
39138 static constexpr bool traverse{true};
39139 static constexpr auto mbr_ptr{&SgAsmCilMetadataHeap::p_EventTable};
39140 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39141 using bind = Desc<SgAsmCilMetadataHeap, SgAsmCilEventTable* SgAsmCilMetadataHeap::*, &SgAsmCilMetadataHeap::p_EventTable>;
39142};
39143template <> struct describe_field_t<SgAsmCilMetadataHeap,SgAsmCilEventMapTable*,&SgAsmCilMetadataHeap::p_EventMapTable> {
39146 static constexpr size_t position{20};
39147 static constexpr char const * const name{"EventMapTable"};
39148 static constexpr char const * const typestr{"SgAsmCilEventMapTable*"};
39149 static constexpr bool traverse{true};
39150 static constexpr auto mbr_ptr{&SgAsmCilMetadataHeap::p_EventMapTable};
39151 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39152 using bind = Desc<SgAsmCilMetadataHeap, SgAsmCilEventMapTable* SgAsmCilMetadataHeap::*, &SgAsmCilMetadataHeap::p_EventMapTable>;
39153};
39154template <> struct describe_field_t<SgAsmCilMetadataHeap,SgAsmCilExportedTypeTable*,&SgAsmCilMetadataHeap::p_ExportedTypeTable> {
39157 static constexpr size_t position{21};
39158 static constexpr char const * const name{"ExportedTypeTable"};
39159 static constexpr char const * const typestr{"SgAsmCilExportedTypeTable*"};
39160 static constexpr bool traverse{true};
39161 static constexpr auto mbr_ptr{&SgAsmCilMetadataHeap::p_ExportedTypeTable};
39162 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39163 using bind = Desc<SgAsmCilMetadataHeap, SgAsmCilExportedTypeTable* SgAsmCilMetadataHeap::*, &SgAsmCilMetadataHeap::p_ExportedTypeTable>;
39164};
39165template <> struct describe_field_t<SgAsmCilMetadataHeap,SgAsmCilFieldTable*,&SgAsmCilMetadataHeap::p_FieldTable> {
39168 static constexpr size_t position{22};
39169 static constexpr char const * const name{"FieldTable"};
39170 static constexpr char const * const typestr{"SgAsmCilFieldTable*"};
39171 static constexpr bool traverse{true};
39172 static constexpr auto mbr_ptr{&SgAsmCilMetadataHeap::p_FieldTable};
39173 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39174 using bind = Desc<SgAsmCilMetadataHeap, SgAsmCilFieldTable* SgAsmCilMetadataHeap::*, &SgAsmCilMetadataHeap::p_FieldTable>;
39175};
39176template <> struct describe_field_t<SgAsmCilMetadataHeap,SgAsmCilFieldLayoutTable*,&SgAsmCilMetadataHeap::p_FieldLayoutTable> {
39179 static constexpr size_t position{23};
39180 static constexpr char const * const name{"FieldLayoutTable"};
39181 static constexpr char const * const typestr{"SgAsmCilFieldLayoutTable*"};
39182 static constexpr bool traverse{true};
39183 static constexpr auto mbr_ptr{&SgAsmCilMetadataHeap::p_FieldLayoutTable};
39184 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39185 using bind = Desc<SgAsmCilMetadataHeap, SgAsmCilFieldLayoutTable* SgAsmCilMetadataHeap::*, &SgAsmCilMetadataHeap::p_FieldLayoutTable>;
39186};
39187template <> struct describe_field_t<SgAsmCilMetadataHeap,SgAsmCilFieldMarshalTable*,&SgAsmCilMetadataHeap::p_FieldMarshalTable> {
39190 static constexpr size_t position{24};
39191 static constexpr char const * const name{"FieldMarshalTable"};
39192 static constexpr char const * const typestr{"SgAsmCilFieldMarshalTable*"};
39193 static constexpr bool traverse{true};
39194 static constexpr auto mbr_ptr{&SgAsmCilMetadataHeap::p_FieldMarshalTable};
39195 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39196 using bind = Desc<SgAsmCilMetadataHeap, SgAsmCilFieldMarshalTable* SgAsmCilMetadataHeap::*, &SgAsmCilMetadataHeap::p_FieldMarshalTable>;
39197};
39198template <> struct describe_field_t<SgAsmCilMetadataHeap,SgAsmCilFieldRVATable*,&SgAsmCilMetadataHeap::p_FieldRVATable> {
39201 static constexpr size_t position{25};
39202 static constexpr char const * const name{"FieldRVATable"};
39203 static constexpr char const * const typestr{"SgAsmCilFieldRVATable*"};
39204 static constexpr bool traverse{true};
39205 static constexpr auto mbr_ptr{&SgAsmCilMetadataHeap::p_FieldRVATable};
39206 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39207 using bind = Desc<SgAsmCilMetadataHeap, SgAsmCilFieldRVATable* SgAsmCilMetadataHeap::*, &SgAsmCilMetadataHeap::p_FieldRVATable>;
39208};
39209template <> struct describe_field_t<SgAsmCilMetadataHeap,SgAsmCilFileTable*,&SgAsmCilMetadataHeap::p_FileTable> {
39212 static constexpr size_t position{26};
39213 static constexpr char const * const name{"FileTable"};
39214 static constexpr char const * const typestr{"SgAsmCilFileTable*"};
39215 static constexpr bool traverse{true};
39216 static constexpr auto mbr_ptr{&SgAsmCilMetadataHeap::p_FileTable};
39217 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39218 using bind = Desc<SgAsmCilMetadataHeap, SgAsmCilFileTable* SgAsmCilMetadataHeap::*, &SgAsmCilMetadataHeap::p_FileTable>;
39219};
39220template <> struct describe_field_t<SgAsmCilMetadataHeap,SgAsmCilGenericParamTable*,&SgAsmCilMetadataHeap::p_GenericParamTable> {
39223 static constexpr size_t position{27};
39224 static constexpr char const * const name{"GenericParamTable"};
39225 static constexpr char const * const typestr{"SgAsmCilGenericParamTable*"};
39226 static constexpr bool traverse{true};
39227 static constexpr auto mbr_ptr{&SgAsmCilMetadataHeap::p_GenericParamTable};
39228 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39229 using bind = Desc<SgAsmCilMetadataHeap, SgAsmCilGenericParamTable* SgAsmCilMetadataHeap::*, &SgAsmCilMetadataHeap::p_GenericParamTable>;
39230};
39231template <> struct describe_field_t<SgAsmCilMetadataHeap,SgAsmCilGenericParamConstraintTable*,&SgAsmCilMetadataHeap::p_GenericParamConstraintTable> {
39234 static constexpr size_t position{28};
39235 static constexpr char const * const name{"GenericParamConstraintTable"};
39236 static constexpr char const * const typestr{"SgAsmCilGenericParamConstraintTable*"};
39237 static constexpr bool traverse{true};
39238 static constexpr auto mbr_ptr{&SgAsmCilMetadataHeap::p_GenericParamConstraintTable};
39239 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39240 using bind = Desc<SgAsmCilMetadataHeap, SgAsmCilGenericParamConstraintTable* SgAsmCilMetadataHeap::*, &SgAsmCilMetadataHeap::p_GenericParamConstraintTable>;
39241};
39242template <> struct describe_field_t<SgAsmCilMetadataHeap,SgAsmCilImplMapTable*,&SgAsmCilMetadataHeap::p_ImplMapTable> {
39245 static constexpr size_t position{29};
39246 static constexpr char const * const name{"ImplMapTable"};
39247 static constexpr char const * const typestr{"SgAsmCilImplMapTable*"};
39248 static constexpr bool traverse{true};
39249 static constexpr auto mbr_ptr{&SgAsmCilMetadataHeap::p_ImplMapTable};
39250 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39251 using bind = Desc<SgAsmCilMetadataHeap, SgAsmCilImplMapTable* SgAsmCilMetadataHeap::*, &SgAsmCilMetadataHeap::p_ImplMapTable>;
39252};
39253template <> struct describe_field_t<SgAsmCilMetadataHeap,SgAsmCilInterfaceImplTable*,&SgAsmCilMetadataHeap::p_InterfaceImplTable> {
39256 static constexpr size_t position{30};
39257 static constexpr char const * const name{"InterfaceImplTable"};
39258 static constexpr char const * const typestr{"SgAsmCilInterfaceImplTable*"};
39259 static constexpr bool traverse{true};
39260 static constexpr auto mbr_ptr{&SgAsmCilMetadataHeap::p_InterfaceImplTable};
39261 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39262 using bind = Desc<SgAsmCilMetadataHeap, SgAsmCilInterfaceImplTable* SgAsmCilMetadataHeap::*, &SgAsmCilMetadataHeap::p_InterfaceImplTable>;
39263};
39264template <> struct describe_field_t<SgAsmCilMetadataHeap,SgAsmCilManifestResourceTable*,&SgAsmCilMetadataHeap::p_ManifestResourceTable> {
39267 static constexpr size_t position{31};
39268 static constexpr char const * const name{"ManifestResourceTable"};
39269 static constexpr char const * const typestr{"SgAsmCilManifestResourceTable*"};
39270 static constexpr bool traverse{true};
39271 static constexpr auto mbr_ptr{&SgAsmCilMetadataHeap::p_ManifestResourceTable};
39272 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39273 using bind = Desc<SgAsmCilMetadataHeap, SgAsmCilManifestResourceTable* SgAsmCilMetadataHeap::*, &SgAsmCilMetadataHeap::p_ManifestResourceTable>;
39274};
39275template <> struct describe_field_t<SgAsmCilMetadataHeap,SgAsmCilMemberRefTable*,&SgAsmCilMetadataHeap::p_MemberRefTable> {
39278 static constexpr size_t position{32};
39279 static constexpr char const * const name{"MemberRefTable"};
39280 static constexpr char const * const typestr{"SgAsmCilMemberRefTable*"};
39281 static constexpr bool traverse{true};
39282 static constexpr auto mbr_ptr{&SgAsmCilMetadataHeap::p_MemberRefTable};
39283 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39284 using bind = Desc<SgAsmCilMetadataHeap, SgAsmCilMemberRefTable* SgAsmCilMetadataHeap::*, &SgAsmCilMetadataHeap::p_MemberRefTable>;
39285};
39286template <> struct describe_field_t<SgAsmCilMetadataHeap,SgAsmCilMethodDefTable*,&SgAsmCilMetadataHeap::p_MethodDefTable> {
39289 static constexpr size_t position{33};
39290 static constexpr char const * const name{"MethodDefTable"};
39291 static constexpr char const * const typestr{"SgAsmCilMethodDefTable*"};
39292 static constexpr bool traverse{true};
39293 static constexpr auto mbr_ptr{&SgAsmCilMetadataHeap::p_MethodDefTable};
39294 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39295 using bind = Desc<SgAsmCilMetadataHeap, SgAsmCilMethodDefTable* SgAsmCilMetadataHeap::*, &SgAsmCilMetadataHeap::p_MethodDefTable>;
39296};
39297template <> struct describe_field_t<SgAsmCilMetadataHeap,SgAsmCilMethodImplTable*,&SgAsmCilMetadataHeap::p_MethodImplTable> {
39300 static constexpr size_t position{34};
39301 static constexpr char const * const name{"MethodImplTable"};
39302 static constexpr char const * const typestr{"SgAsmCilMethodImplTable*"};
39303 static constexpr bool traverse{true};
39304 static constexpr auto mbr_ptr{&SgAsmCilMetadataHeap::p_MethodImplTable};
39305 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39306 using bind = Desc<SgAsmCilMetadataHeap, SgAsmCilMethodImplTable* SgAsmCilMetadataHeap::*, &SgAsmCilMetadataHeap::p_MethodImplTable>;
39307};
39308template <> struct describe_field_t<SgAsmCilMetadataHeap,SgAsmCilMethodSemanticsTable*,&SgAsmCilMetadataHeap::p_MethodSemanticsTable> {
39311 static constexpr size_t position{35};
39312 static constexpr char const * const name{"MethodSemanticsTable"};
39313 static constexpr char const * const typestr{"SgAsmCilMethodSemanticsTable*"};
39314 static constexpr bool traverse{true};
39315 static constexpr auto mbr_ptr{&SgAsmCilMetadataHeap::p_MethodSemanticsTable};
39316 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39317 using bind = Desc<SgAsmCilMetadataHeap, SgAsmCilMethodSemanticsTable* SgAsmCilMetadataHeap::*, &SgAsmCilMetadataHeap::p_MethodSemanticsTable>;
39318};
39319template <> struct describe_field_t<SgAsmCilMetadataHeap,SgAsmCilMethodSpecTable*,&SgAsmCilMetadataHeap::p_MethodSpecTable> {
39322 static constexpr size_t position{36};
39323 static constexpr char const * const name{"MethodSpecTable"};
39324 static constexpr char const * const typestr{"SgAsmCilMethodSpecTable*"};
39325 static constexpr bool traverse{true};
39326 static constexpr auto mbr_ptr{&SgAsmCilMetadataHeap::p_MethodSpecTable};
39327 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39328 using bind = Desc<SgAsmCilMetadataHeap, SgAsmCilMethodSpecTable* SgAsmCilMetadataHeap::*, &SgAsmCilMetadataHeap::p_MethodSpecTable>;
39329};
39330template <> struct describe_field_t<SgAsmCilMetadataHeap,SgAsmCilModuleTable*,&SgAsmCilMetadataHeap::p_ModuleTable> {
39333 static constexpr size_t position{37};
39334 static constexpr char const * const name{"ModuleTable"};
39335 static constexpr char const * const typestr{"SgAsmCilModuleTable*"};
39336 static constexpr bool traverse{true};
39337 static constexpr auto mbr_ptr{&SgAsmCilMetadataHeap::p_ModuleTable};
39338 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39339 using bind = Desc<SgAsmCilMetadataHeap, SgAsmCilModuleTable* SgAsmCilMetadataHeap::*, &SgAsmCilMetadataHeap::p_ModuleTable>;
39340};
39341template <> struct describe_field_t<SgAsmCilMetadataHeap,SgAsmCilModuleRefTable*,&SgAsmCilMetadataHeap::p_ModuleRefTable> {
39344 static constexpr size_t position{38};
39345 static constexpr char const * const name{"ModuleRefTable"};
39346 static constexpr char const * const typestr{"SgAsmCilModuleRefTable*"};
39347 static constexpr bool traverse{true};
39348 static constexpr auto mbr_ptr{&SgAsmCilMetadataHeap::p_ModuleRefTable};
39349 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39350 using bind = Desc<SgAsmCilMetadataHeap, SgAsmCilModuleRefTable* SgAsmCilMetadataHeap::*, &SgAsmCilMetadataHeap::p_ModuleRefTable>;
39351};
39352template <> struct describe_field_t<SgAsmCilMetadataHeap,SgAsmCilNestedClassTable*,&SgAsmCilMetadataHeap::p_NestedClassTable> {
39355 static constexpr size_t position{39};
39356 static constexpr char const * const name{"NestedClassTable"};
39357 static constexpr char const * const typestr{"SgAsmCilNestedClassTable*"};
39358 static constexpr bool traverse{true};
39359 static constexpr auto mbr_ptr{&SgAsmCilMetadataHeap::p_NestedClassTable};
39360 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39361 using bind = Desc<SgAsmCilMetadataHeap, SgAsmCilNestedClassTable* SgAsmCilMetadataHeap::*, &SgAsmCilMetadataHeap::p_NestedClassTable>;
39362};
39363template <> struct describe_field_t<SgAsmCilMetadataHeap,SgAsmCilParamTable*,&SgAsmCilMetadataHeap::p_ParamTable> {
39366 static constexpr size_t position{40};
39367 static constexpr char const * const name{"ParamTable"};
39368 static constexpr char const * const typestr{"SgAsmCilParamTable*"};
39369 static constexpr bool traverse{true};
39370 static constexpr auto mbr_ptr{&SgAsmCilMetadataHeap::p_ParamTable};
39371 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39372 using bind = Desc<SgAsmCilMetadataHeap, SgAsmCilParamTable* SgAsmCilMetadataHeap::*, &SgAsmCilMetadataHeap::p_ParamTable>;
39373};
39374template <> struct describe_field_t<SgAsmCilMetadataHeap,SgAsmCilPropertyTable*,&SgAsmCilMetadataHeap::p_PropertyTable> {
39377 static constexpr size_t position{41};
39378 static constexpr char const * const name{"PropertyTable"};
39379 static constexpr char const * const typestr{"SgAsmCilPropertyTable*"};
39380 static constexpr bool traverse{true};
39381 static constexpr auto mbr_ptr{&SgAsmCilMetadataHeap::p_PropertyTable};
39382 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39383 using bind = Desc<SgAsmCilMetadataHeap, SgAsmCilPropertyTable* SgAsmCilMetadataHeap::*, &SgAsmCilMetadataHeap::p_PropertyTable>;
39384};
39385template <> struct describe_field_t<SgAsmCilMetadataHeap,SgAsmCilPropertyMapTable*,&SgAsmCilMetadataHeap::p_PropertyMapTable> {
39388 static constexpr size_t position{42};
39389 static constexpr char const * const name{"PropertyMapTable"};
39390 static constexpr char const * const typestr{"SgAsmCilPropertyMapTable*"};
39391 static constexpr bool traverse{true};
39392 static constexpr auto mbr_ptr{&SgAsmCilMetadataHeap::p_PropertyMapTable};
39393 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39394 using bind = Desc<SgAsmCilMetadataHeap, SgAsmCilPropertyMapTable* SgAsmCilMetadataHeap::*, &SgAsmCilMetadataHeap::p_PropertyMapTable>;
39395};
39396template <> struct describe_field_t<SgAsmCilMetadataHeap,SgAsmCilStandAloneSigTable*,&SgAsmCilMetadataHeap::p_StandAloneSigTable> {
39399 static constexpr size_t position{43};
39400 static constexpr char const * const name{"StandAloneSigTable"};
39401 static constexpr char const * const typestr{"SgAsmCilStandAloneSigTable*"};
39402 static constexpr bool traverse{true};
39403 static constexpr auto mbr_ptr{&SgAsmCilMetadataHeap::p_StandAloneSigTable};
39404 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39405 using bind = Desc<SgAsmCilMetadataHeap, SgAsmCilStandAloneSigTable* SgAsmCilMetadataHeap::*, &SgAsmCilMetadataHeap::p_StandAloneSigTable>;
39406};
39407template <> struct describe_field_t<SgAsmCilMetadataHeap,SgAsmCilTypeDefTable*,&SgAsmCilMetadataHeap::p_TypeDefTable> {
39410 static constexpr size_t position{44};
39411 static constexpr char const * const name{"TypeDefTable"};
39412 static constexpr char const * const typestr{"SgAsmCilTypeDefTable*"};
39413 static constexpr bool traverse{true};
39414 static constexpr auto mbr_ptr{&SgAsmCilMetadataHeap::p_TypeDefTable};
39415 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39416 using bind = Desc<SgAsmCilMetadataHeap, SgAsmCilTypeDefTable* SgAsmCilMetadataHeap::*, &SgAsmCilMetadataHeap::p_TypeDefTable>;
39417};
39418template <> struct describe_field_t<SgAsmCilMetadataHeap,SgAsmCilTypeRefTable*,&SgAsmCilMetadataHeap::p_TypeRefTable> {
39421 static constexpr size_t position{45};
39422 static constexpr char const * const name{"TypeRefTable"};
39423 static constexpr char const * const typestr{"SgAsmCilTypeRefTable*"};
39424 static constexpr bool traverse{true};
39425 static constexpr auto mbr_ptr{&SgAsmCilMetadataHeap::p_TypeRefTable};
39426 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39427 using bind = Desc<SgAsmCilMetadataHeap, SgAsmCilTypeRefTable* SgAsmCilMetadataHeap::*, &SgAsmCilMetadataHeap::p_TypeRefTable>;
39428};
39429template <> struct describe_field_t<SgAsmCilMetadataHeap,SgAsmCilTypeSpecTable*,&SgAsmCilMetadataHeap::p_TypeSpecTable> {
39432 static constexpr size_t position{46};
39433 static constexpr char const * const name{"TypeSpecTable"};
39434 static constexpr char const * const typestr{"SgAsmCilTypeSpecTable*"};
39435 static constexpr bool traverse{true};
39436 static constexpr auto mbr_ptr{&SgAsmCilMetadataHeap::p_TypeSpecTable};
39437 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39438 using bind = Desc<SgAsmCilMetadataHeap, SgAsmCilTypeSpecTable* SgAsmCilMetadataHeap::*, &SgAsmCilMetadataHeap::p_TypeSpecTable>;
39439};
39441 using node = SgAsmCilMetadataHeap;
39442 using base = SgAsmCilDataStream;
39443 static constexpr char const * const name{"AsmCilMetadataHeap"};
39444 static constexpr unsigned long variant{994};
39445 static constexpr bool concrete{true};
39446 using subclasses_t = mp::List<>;
39447 using fields_t = mp::List<describe_field_t<SgAsmCilMetadataHeap,uint32_t,&SgAsmCilMetadataHeap::p_ReservedAlwaysZero>, describe_field_t<SgAsmCilMetadataHeap,uint8_t,&SgAsmCilMetadataHeap::p_MajorVersion>, describe_field_t<SgAsmCilMetadataHeap,uint8_t,&SgAsmCilMetadataHeap::p_MinorVersion>, describe_field_t<SgAsmCilMetadataHeap,uint8_t,&SgAsmCilMetadataHeap::p_HeapSizes>, describe_field_t<SgAsmCilMetadataHeap,uint8_t,&SgAsmCilMetadataHeap::p_ReservedAlwaysOne>, describe_field_t<SgAsmCilMetadataHeap,uint64_t,&SgAsmCilMetadataHeap::p_Valid>, describe_field_t<SgAsmCilMetadataHeap,uint64_t,&SgAsmCilMetadataHeap::p_Sorted>, describe_field_t<SgAsmCilMetadataHeap,std::vector<uint32_t>,&SgAsmCilMetadataHeap::p_NumberOfRows>, describe_field_t<SgAsmCilMetadataHeap,uint64_t,&SgAsmCilMetadataHeap::p_DataSizeFlags>, describe_field_t<SgAsmCilMetadataHeap,SgAsmCilAssemblyTable*,&SgAsmCilMetadataHeap::p_AssemblyTable>, describe_field_t<SgAsmCilMetadataHeap,SgAsmCilAssemblyOSTable*,&SgAsmCilMetadataHeap::p_AssemblyOSTable>, describe_field_t<SgAsmCilMetadataHeap,SgAsmCilAssemblyProcessorTable*,&SgAsmCilMetadataHeap::p_AssemblyProcessorTable>, describe_field_t<SgAsmCilMetadataHeap,SgAsmCilAssemblyRefTable*,&SgAsmCilMetadataHeap::p_AssemblyRefTable>, describe_field_t<SgAsmCilMetadataHeap,SgAsmCilAssemblyRefOSTable*,&SgAsmCilMetadataHeap::p_AssemblyRefOSTable>, describe_field_t<SgAsmCilMetadataHeap,SgAsmCilAssemblyRefProcessorTable*,&SgAsmCilMetadataHeap::p_AssemblyRefProcessorTable>, describe_field_t<SgAsmCilMetadataHeap,SgAsmCilClassLayoutTable*,&SgAsmCilMetadataHeap::p_ClassLayoutTable>, describe_field_t<SgAsmCilMetadataHeap,SgAsmCilConstantTable*,&SgAsmCilMetadataHeap::p_ConstantTable>, describe_field_t<SgAsmCilMetadataHeap,SgAsmCilCustomAttributeTable*,&SgAsmCilMetadataHeap::p_CustomAttributeTable>, describe_field_t<SgAsmCilMetadataHeap,SgAsmCilDeclSecurityTable*,&SgAsmCilMetadataHeap::p_DeclSecurityTable>, describe_field_t<SgAsmCilMetadataHeap,SgAsmCilEventTable*,&SgAsmCilMetadataHeap::p_EventTable>, describe_field_t<SgAsmCilMetadataHeap,SgAsmCilEventMapTable*,&SgAsmCilMetadataHeap::p_EventMapTable>, describe_field_t<SgAsmCilMetadataHeap,SgAsmCilExportedTypeTable*,&SgAsmCilMetadataHeap::p_ExportedTypeTable>, describe_field_t<SgAsmCilMetadataHeap,SgAsmCilFieldTable*,&SgAsmCilMetadataHeap::p_FieldTable>, describe_field_t<SgAsmCilMetadataHeap,SgAsmCilFieldLayoutTable*,&SgAsmCilMetadataHeap::p_FieldLayoutTable>, describe_field_t<SgAsmCilMetadataHeap,SgAsmCilFieldMarshalTable*,&SgAsmCilMetadataHeap::p_FieldMarshalTable>, describe_field_t<SgAsmCilMetadataHeap,SgAsmCilFieldRVATable*,&SgAsmCilMetadataHeap::p_FieldRVATable>, describe_field_t<SgAsmCilMetadataHeap,SgAsmCilFileTable*,&SgAsmCilMetadataHeap::p_FileTable>, describe_field_t<SgAsmCilMetadataHeap,SgAsmCilGenericParamTable*,&SgAsmCilMetadataHeap::p_GenericParamTable>, describe_field_t<SgAsmCilMetadataHeap,SgAsmCilGenericParamConstraintTable*,&SgAsmCilMetadataHeap::p_GenericParamConstraintTable>, describe_field_t<SgAsmCilMetadataHeap,SgAsmCilImplMapTable*,&SgAsmCilMetadataHeap::p_ImplMapTable>, describe_field_t<SgAsmCilMetadataHeap,SgAsmCilInterfaceImplTable*,&SgAsmCilMetadataHeap::p_InterfaceImplTable>, describe_field_t<SgAsmCilMetadataHeap,SgAsmCilManifestResourceTable*,&SgAsmCilMetadataHeap::p_ManifestResourceTable>, describe_field_t<SgAsmCilMetadataHeap,SgAsmCilMemberRefTable*,&SgAsmCilMetadataHeap::p_MemberRefTable>, describe_field_t<SgAsmCilMetadataHeap,SgAsmCilMethodDefTable*,&SgAsmCilMetadataHeap::p_MethodDefTable>, describe_field_t<SgAsmCilMetadataHeap,SgAsmCilMethodImplTable*,&SgAsmCilMetadataHeap::p_MethodImplTable>, describe_field_t<SgAsmCilMetadataHeap,SgAsmCilMethodSemanticsTable*,&SgAsmCilMetadataHeap::p_MethodSemanticsTable>, describe_field_t<SgAsmCilMetadataHeap,SgAsmCilMethodSpecTable*,&SgAsmCilMetadataHeap::p_MethodSpecTable>, describe_field_t<SgAsmCilMetadataHeap,SgAsmCilModuleTable*,&SgAsmCilMetadataHeap::p_ModuleTable>, describe_field_t<SgAsmCilMetadataHeap,SgAsmCilModuleRefTable*,&SgAsmCilMetadataHeap::p_ModuleRefTable>, describe_field_t<SgAsmCilMetadataHeap,SgAsmCilNestedClassTable*,&SgAsmCilMetadataHeap::p_NestedClassTable>, describe_field_t<SgAsmCilMetadataHeap,SgAsmCilParamTable*,&SgAsmCilMetadataHeap::p_ParamTable>, describe_field_t<SgAsmCilMetadataHeap,SgAsmCilPropertyTable*,&SgAsmCilMetadataHeap::p_PropertyTable>, describe_field_t<SgAsmCilMetadataHeap,SgAsmCilPropertyMapTable*,&SgAsmCilMetadataHeap::p_PropertyMapTable>, describe_field_t<SgAsmCilMetadataHeap,SgAsmCilStandAloneSigTable*,&SgAsmCilMetadataHeap::p_StandAloneSigTable>, describe_field_t<SgAsmCilMetadataHeap,SgAsmCilTypeDefTable*,&SgAsmCilMetadataHeap::p_TypeDefTable>, describe_field_t<SgAsmCilMetadataHeap,SgAsmCilTypeRefTable*,&SgAsmCilMetadataHeap::p_TypeRefTable>, describe_field_t<SgAsmCilMetadataHeap,SgAsmCilTypeSpecTable*,&SgAsmCilMetadataHeap::p_TypeSpecTable>>;
39448};
39449template <> struct node_from_variant_t<994> { using type = SgAsmCilMetadataHeap; };
39450
39451// Class: AsmCilUint8Heap
39452template <> struct describe_field_t<SgAsmCilUint8Heap,std::vector<uint8_t>,&SgAsmCilUint8Heap::p_Stream> {
39453 using parent = SgAsmCilUint8Heap;
39454 using field_type = std::vector<uint8_t>;
39455 static constexpr size_t position{0};
39456 static constexpr char const * const name{"Stream"};
39457 static constexpr char const * const typestr{"std::vector<uint8_t>"};
39458 static constexpr bool traverse{false};
39459 static constexpr auto mbr_ptr{&SgAsmCilUint8Heap::p_Stream};
39460 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39461 using bind = Desc<SgAsmCilUint8Heap, std::vector<uint8_t> SgAsmCilUint8Heap::*, &SgAsmCilUint8Heap::p_Stream>;
39462};
39464 using node = SgAsmCilUint8Heap;
39465 using base = SgAsmCilDataStream;
39466 static constexpr char const * const name{"AsmCilUint8Heap"};
39467 static constexpr unsigned long variant{995};
39468 static constexpr bool concrete{true};
39469 using subclasses_t = mp::List<>;
39471};
39472template <> struct node_from_variant_t<995> { using type = SgAsmCilUint8Heap; };
39473
39474// Class: AsmCilUint32Heap
39475template <> struct describe_field_t<SgAsmCilUint32Heap,std::vector<uint32_t>,&SgAsmCilUint32Heap::p_Stream> {
39476 using parent = SgAsmCilUint32Heap;
39477 using field_type = std::vector<uint32_t>;
39478 static constexpr size_t position{0};
39479 static constexpr char const * const name{"Stream"};
39480 static constexpr char const * const typestr{"std::vector<uint32_t>"};
39481 static constexpr bool traverse{false};
39482 static constexpr auto mbr_ptr{&SgAsmCilUint32Heap::p_Stream};
39483 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39484 using bind = Desc<SgAsmCilUint32Heap, std::vector<uint32_t> SgAsmCilUint32Heap::*, &SgAsmCilUint32Heap::p_Stream>;
39485};
39487 using node = SgAsmCilUint32Heap;
39488 using base = SgAsmCilDataStream;
39489 static constexpr char const * const name{"AsmCilUint32Heap"};
39490 static constexpr unsigned long variant{996};
39491 static constexpr bool concrete{true};
39492 using subclasses_t = mp::List<>;
39494};
39495template <> struct node_from_variant_t<996> { using type = SgAsmCilUint32Heap; };
39496
39497// Class: AsmCliHeader
39498template <> struct describe_field_t<SgAsmCliHeader,uint32_t,&SgAsmCliHeader::p_cb> {
39499 using parent = SgAsmCliHeader;
39500 using field_type = uint32_t;
39501 static constexpr size_t position{0};
39502 static constexpr char const * const name{"cb"};
39503 static constexpr char const * const typestr{"uint32_t"};
39504 static constexpr bool traverse{false};
39505 static constexpr auto mbr_ptr{&SgAsmCliHeader::p_cb};
39506 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39507 using bind = Desc<SgAsmCliHeader, uint32_t SgAsmCliHeader::*, &SgAsmCliHeader::p_cb>;
39508};
39509template <> struct describe_field_t<SgAsmCliHeader,uint16_t,&SgAsmCliHeader::p_majorRuntimeVersion> {
39510 using parent = SgAsmCliHeader;
39511 using field_type = uint16_t;
39512 static constexpr size_t position{1};
39513 static constexpr char const * const name{"majorRuntimeVersion"};
39514 static constexpr char const * const typestr{"uint16_t"};
39515 static constexpr bool traverse{false};
39516 static constexpr auto mbr_ptr{&SgAsmCliHeader::p_majorRuntimeVersion};
39517 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39518 using bind = Desc<SgAsmCliHeader, uint16_t SgAsmCliHeader::*, &SgAsmCliHeader::p_majorRuntimeVersion>;
39519};
39520template <> struct describe_field_t<SgAsmCliHeader,uint16_t,&SgAsmCliHeader::p_minorRuntimeVersion> {
39521 using parent = SgAsmCliHeader;
39522 using field_type = uint16_t;
39523 static constexpr size_t position{2};
39524 static constexpr char const * const name{"minorRuntimeVersion"};
39525 static constexpr char const * const typestr{"uint16_t"};
39526 static constexpr bool traverse{false};
39527 static constexpr auto mbr_ptr{&SgAsmCliHeader::p_minorRuntimeVersion};
39528 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39529 using bind = Desc<SgAsmCliHeader, uint16_t SgAsmCliHeader::*, &SgAsmCliHeader::p_minorRuntimeVersion>;
39530};
39531template <> struct describe_field_t<SgAsmCliHeader,uint64_t,&SgAsmCliHeader::p_metaData> {
39532 using parent = SgAsmCliHeader;
39533 using field_type = uint64_t;
39534 static constexpr size_t position{3};
39535 static constexpr char const * const name{"metaData"};
39536 static constexpr char const * const typestr{"uint64_t"};
39537 static constexpr bool traverse{false};
39538 static constexpr auto mbr_ptr{&SgAsmCliHeader::p_metaData};
39539 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39540 using bind = Desc<SgAsmCliHeader, uint64_t SgAsmCliHeader::*, &SgAsmCliHeader::p_metaData>;
39541};
39542template <> struct describe_field_t<SgAsmCliHeader,uint32_t,&SgAsmCliHeader::p_flags> {
39543 using parent = SgAsmCliHeader;
39544 using field_type = uint32_t;
39545 static constexpr size_t position{4};
39546 static constexpr char const * const name{"flags"};
39547 static constexpr char const * const typestr{"uint32_t"};
39548 static constexpr bool traverse{false};
39549 static constexpr auto mbr_ptr{&SgAsmCliHeader::p_flags};
39550 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39551 using bind = Desc<SgAsmCliHeader, uint32_t SgAsmCliHeader::*, &SgAsmCliHeader::p_flags>;
39552};
39553template <> struct describe_field_t<SgAsmCliHeader,uint32_t,&SgAsmCliHeader::p_entryPointToken> {
39554 using parent = SgAsmCliHeader;
39555 using field_type = uint32_t;
39556 static constexpr size_t position{5};
39557 static constexpr char const * const name{"entryPointToken"};
39558 static constexpr char const * const typestr{"uint32_t"};
39559 static constexpr bool traverse{false};
39560 static constexpr auto mbr_ptr{&SgAsmCliHeader::p_entryPointToken};
39561 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39562 using bind = Desc<SgAsmCliHeader, uint32_t SgAsmCliHeader::*, &SgAsmCliHeader::p_entryPointToken>;
39563};
39564template <> struct describe_field_t<SgAsmCliHeader,uint64_t,&SgAsmCliHeader::p_resources> {
39565 using parent = SgAsmCliHeader;
39566 using field_type = uint64_t;
39567 static constexpr size_t position{6};
39568 static constexpr char const * const name{"resources"};
39569 static constexpr char const * const typestr{"uint64_t"};
39570 static constexpr bool traverse{false};
39571 static constexpr auto mbr_ptr{&SgAsmCliHeader::p_resources};
39572 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39573 using bind = Desc<SgAsmCliHeader, uint64_t SgAsmCliHeader::*, &SgAsmCliHeader::p_resources>;
39574};
39575template <> struct describe_field_t<SgAsmCliHeader,uint64_t,&SgAsmCliHeader::p_strongNameSignature> {
39576 using parent = SgAsmCliHeader;
39577 using field_type = uint64_t;
39578 static constexpr size_t position{7};
39579 static constexpr char const * const name{"strongNameSignature"};
39580 static constexpr char const * const typestr{"uint64_t"};
39581 static constexpr bool traverse{false};
39582 static constexpr auto mbr_ptr{&SgAsmCliHeader::p_strongNameSignature};
39583 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39584 using bind = Desc<SgAsmCliHeader, uint64_t SgAsmCliHeader::*, &SgAsmCliHeader::p_strongNameSignature>;
39585};
39586template <> struct describe_field_t<SgAsmCliHeader,uint64_t,&SgAsmCliHeader::p_codeManagerTable> {
39587 using parent = SgAsmCliHeader;
39588 using field_type = uint64_t;
39589 static constexpr size_t position{8};
39590 static constexpr char const * const name{"codeManagerTable"};
39591 static constexpr char const * const typestr{"uint64_t"};
39592 static constexpr bool traverse{false};
39593 static constexpr auto mbr_ptr{&SgAsmCliHeader::p_codeManagerTable};
39594 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39595 using bind = Desc<SgAsmCliHeader, uint64_t SgAsmCliHeader::*, &SgAsmCliHeader::p_codeManagerTable>;
39596};
39597template <> struct describe_field_t<SgAsmCliHeader,uint64_t,&SgAsmCliHeader::p_vTableFixups> {
39598 using parent = SgAsmCliHeader;
39599 using field_type = uint64_t;
39600 static constexpr size_t position{9};
39601 static constexpr char const * const name{"vTableFixups"};
39602 static constexpr char const * const typestr{"uint64_t"};
39603 static constexpr bool traverse{false};
39604 static constexpr auto mbr_ptr{&SgAsmCliHeader::p_vTableFixups};
39605 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39606 using bind = Desc<SgAsmCliHeader, uint64_t SgAsmCliHeader::*, &SgAsmCliHeader::p_vTableFixups>;
39607};
39608template <> struct describe_field_t<SgAsmCliHeader,uint64_t,&SgAsmCliHeader::p_exportAddressTableJumps> {
39609 using parent = SgAsmCliHeader;
39610 using field_type = uint64_t;
39611 static constexpr size_t position{10};
39612 static constexpr char const * const name{"exportAddressTableJumps"};
39613 static constexpr char const * const typestr{"uint64_t"};
39614 static constexpr bool traverse{false};
39615 static constexpr auto mbr_ptr{&SgAsmCliHeader::p_exportAddressTableJumps};
39616 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39617 using bind = Desc<SgAsmCliHeader, uint64_t SgAsmCliHeader::*, &SgAsmCliHeader::p_exportAddressTableJumps>;
39618};
39619template <> struct describe_field_t<SgAsmCliHeader,uint64_t,&SgAsmCliHeader::p_managedNativeHeader> {
39620 using parent = SgAsmCliHeader;
39621 using field_type = uint64_t;
39622 static constexpr size_t position{11};
39623 static constexpr char const * const name{"managedNativeHeader"};
39624 static constexpr char const * const typestr{"uint64_t"};
39625 static constexpr bool traverse{false};
39626 static constexpr auto mbr_ptr{&SgAsmCliHeader::p_managedNativeHeader};
39627 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39628 using bind = Desc<SgAsmCliHeader, uint64_t SgAsmCliHeader::*, &SgAsmCliHeader::p_managedNativeHeader>;
39629};
39630template <> struct describe_field_t<SgAsmCliHeader,SgAsmCilMetadataRoot*,&SgAsmCliHeader::p_metadataRoot> {
39631 using parent = SgAsmCliHeader;
39633 static constexpr size_t position{12};
39634 static constexpr char const * const name{"metadataRoot"};
39635 static constexpr char const * const typestr{"SgAsmCilMetadataRoot*"};
39636 static constexpr bool traverse{true};
39637 static constexpr auto mbr_ptr{&SgAsmCliHeader::p_metadataRoot};
39638 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39639 using bind = Desc<SgAsmCliHeader, SgAsmCilMetadataRoot* SgAsmCliHeader::*, &SgAsmCliHeader::p_metadataRoot>;
39640};
39650template <> struct node_from_variant_t<997> { using type = SgAsmCliHeader; };
39651
39652// Class: AdaVariantDecl
39653template <> struct describe_field_t<SgAdaVariantDecl,SgExpression*,&SgAdaVariantDecl::p_discriminant> {
39654 using parent = SgAdaVariantDecl;
39655 using field_type = SgExpression*;
39656 static constexpr size_t position{0};
39657 static constexpr char const * const name{"discriminant"};
39658 static constexpr char const * const typestr{"SgExpression*"};
39659 static constexpr bool traverse{true};
39660 static constexpr auto mbr_ptr{&SgAdaVariantDecl::p_discriminant};
39661 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39662 using bind = Desc<SgAdaVariantDecl, SgExpression* SgAdaVariantDecl::*, &SgAdaVariantDecl::p_discriminant>;
39663};
39664template <> struct describe_field_t<SgAdaVariantDecl,SgAdaUnscopedBlock*,&SgAdaVariantDecl::p_variants> {
39665 using parent = SgAdaVariantDecl;
39667 static constexpr size_t position{1};
39668 static constexpr char const * const name{"variants"};
39669 static constexpr char const * const typestr{"SgAdaUnscopedBlock*"};
39670 static constexpr bool traverse{true};
39671 static constexpr auto mbr_ptr{&SgAdaVariantDecl::p_variants};
39672 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39673 using bind = Desc<SgAdaVariantDecl, SgAdaUnscopedBlock* SgAdaVariantDecl::*, &SgAdaVariantDecl::p_variants>;
39674};
39676 using node = SgAdaVariantDecl;
39678 static constexpr char const * const name{"AdaVariantDecl"};
39679 static constexpr unsigned long variant{998};
39680 static constexpr bool concrete{true};
39681 using subclasses_t = mp::List<>;
39683};
39684template <> struct node_from_variant_t<998> { using type = SgAdaVariantDecl; };
39685
39686// Class: AdaVariantWhenStmt
39687template <> struct describe_field_t<SgAdaVariantWhenStmt,SgExprListExp*,&SgAdaVariantWhenStmt::p_choices> {
39689 using field_type = SgExprListExp*;
39690 static constexpr size_t position{0};
39691 static constexpr char const * const name{"choices"};
39692 static constexpr char const * const typestr{"SgExprListExp*"};
39693 static constexpr bool traverse{true};
39694 static constexpr auto mbr_ptr{&SgAdaVariantWhenStmt::p_choices};
39695 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39696 using bind = Desc<SgAdaVariantWhenStmt, SgExprListExp* SgAdaVariantWhenStmt::*, &SgAdaVariantWhenStmt::p_choices>;
39697};
39698template <> struct describe_field_t<SgAdaVariantWhenStmt,SgAdaUnscopedBlock*,&SgAdaVariantWhenStmt::p_components> {
39701 static constexpr size_t position{1};
39702 static constexpr char const * const name{"components"};
39703 static constexpr char const * const typestr{"SgAdaUnscopedBlock*"};
39704 static constexpr bool traverse{true};
39705 static constexpr auto mbr_ptr{&SgAdaVariantWhenStmt::p_components};
39706 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39707 using bind = Desc<SgAdaVariantWhenStmt, SgAdaUnscopedBlock* SgAdaVariantWhenStmt::*, &SgAdaVariantWhenStmt::p_components>;
39708};
39710 using node = SgAdaVariantWhenStmt;
39711 using base = SgStatement;
39712 static constexpr char const * const name{"AdaVariantWhenStmt"};
39713 static constexpr unsigned long variant{999};
39714 static constexpr bool concrete{true};
39715 using subclasses_t = mp::List<>;
39717};
39718template <> struct node_from_variant_t<999> { using type = SgAdaVariantWhenStmt; };
39719
39720// Class: AsmCilAssemblyTable
39721template <> struct describe_field_t<SgAsmCilAssemblyTable,std::vector<SgAsmCilAssembly*>,&SgAsmCilAssemblyTable::p_elements> {
39723 using field_type = std::vector<SgAsmCilAssembly*>;
39724 static constexpr size_t position{0};
39725 static constexpr char const * const name{"elements"};
39726 static constexpr char const * const typestr{"std::vector<SgAsmCilAssembly*>"};
39727 static constexpr bool traverse{true};
39728 static constexpr auto mbr_ptr{&SgAsmCilAssemblyTable::p_elements};
39729 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39730 using bind = Desc<SgAsmCilAssemblyTable, std::vector<SgAsmCilAssembly*> SgAsmCilAssemblyTable::*, &SgAsmCilAssemblyTable::p_elements>;
39731};
39734 using base = SgAsmCilMetadata;
39735 static constexpr char const * const name{"AsmCilAssemblyTable"};
39736 static constexpr unsigned long variant{1000};
39737 static constexpr bool concrete{true};
39738 using subclasses_t = mp::List<>;
39740};
39741template <> struct node_from_variant_t<1000> { using type = SgAsmCilAssemblyTable; };
39742
39743// Class: AsmCilAssemblyOSTable
39744template <> struct describe_field_t<SgAsmCilAssemblyOSTable,std::vector<SgAsmCilAssemblyOS*>,&SgAsmCilAssemblyOSTable::p_elements> {
39746 using field_type = std::vector<SgAsmCilAssemblyOS*>;
39747 static constexpr size_t position{0};
39748 static constexpr char const * const name{"elements"};
39749 static constexpr char const * const typestr{"std::vector<SgAsmCilAssemblyOS*>"};
39750 static constexpr bool traverse{true};
39751 static constexpr auto mbr_ptr{&SgAsmCilAssemblyOSTable::p_elements};
39752 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39753 using bind = Desc<SgAsmCilAssemblyOSTable, std::vector<SgAsmCilAssemblyOS*> SgAsmCilAssemblyOSTable::*, &SgAsmCilAssemblyOSTable::p_elements>;
39754};
39757 using base = SgAsmCilMetadata;
39758 static constexpr char const * const name{"AsmCilAssemblyOSTable"};
39759 static constexpr unsigned long variant{1001};
39760 static constexpr bool concrete{true};
39761 using subclasses_t = mp::List<>;
39763};
39764template <> struct node_from_variant_t<1001> { using type = SgAsmCilAssemblyOSTable; };
39765
39766// Class: AsmCilAssemblyProcessorTable
39767template <> struct describe_field_t<SgAsmCilAssemblyProcessorTable,std::vector<SgAsmCilAssemblyProcessor*>,&SgAsmCilAssemblyProcessorTable::p_elements> {
39769 using field_type = std::vector<SgAsmCilAssemblyProcessor*>;
39770 static constexpr size_t position{0};
39771 static constexpr char const * const name{"elements"};
39772 static constexpr char const * const typestr{"std::vector<SgAsmCilAssemblyProcessor*>"};
39773 static constexpr bool traverse{true};
39774 static constexpr auto mbr_ptr{&SgAsmCilAssemblyProcessorTable::p_elements};
39775 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39776 using bind = Desc<SgAsmCilAssemblyProcessorTable, std::vector<SgAsmCilAssemblyProcessor*> SgAsmCilAssemblyProcessorTable::*, &SgAsmCilAssemblyProcessorTable::p_elements>;
39777};
39780 using base = SgAsmCilMetadata;
39781 static constexpr char const * const name{"AsmCilAssemblyProcessorTable"};
39782 static constexpr unsigned long variant{1002};
39783 static constexpr bool concrete{true};
39784 using subclasses_t = mp::List<>;
39786};
39787template <> struct node_from_variant_t<1002> { using type = SgAsmCilAssemblyProcessorTable; };
39788
39789// Class: AsmCilAssemblyRefTable
39790template <> struct describe_field_t<SgAsmCilAssemblyRefTable,std::vector<SgAsmCilAssemblyRef*>,&SgAsmCilAssemblyRefTable::p_elements> {
39792 using field_type = std::vector<SgAsmCilAssemblyRef*>;
39793 static constexpr size_t position{0};
39794 static constexpr char const * const name{"elements"};
39795 static constexpr char const * const typestr{"std::vector<SgAsmCilAssemblyRef*>"};
39796 static constexpr bool traverse{true};
39797 static constexpr auto mbr_ptr{&SgAsmCilAssemblyRefTable::p_elements};
39798 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39799 using bind = Desc<SgAsmCilAssemblyRefTable, std::vector<SgAsmCilAssemblyRef*> SgAsmCilAssemblyRefTable::*, &SgAsmCilAssemblyRefTable::p_elements>;
39800};
39803 using base = SgAsmCilMetadata;
39804 static constexpr char const * const name{"AsmCilAssemblyRefTable"};
39805 static constexpr unsigned long variant{1003};
39806 static constexpr bool concrete{true};
39807 using subclasses_t = mp::List<>;
39809};
39810template <> struct node_from_variant_t<1003> { using type = SgAsmCilAssemblyRefTable; };
39811
39812// Class: AsmCilAssemblyRefOSTable
39813template <> struct describe_field_t<SgAsmCilAssemblyRefOSTable,std::vector<SgAsmCilAssemblyRefOS*>,&SgAsmCilAssemblyRefOSTable::p_elements> {
39815 using field_type = std::vector<SgAsmCilAssemblyRefOS*>;
39816 static constexpr size_t position{0};
39817 static constexpr char const * const name{"elements"};
39818 static constexpr char const * const typestr{"std::vector<SgAsmCilAssemblyRefOS*>"};
39819 static constexpr bool traverse{true};
39820 static constexpr auto mbr_ptr{&SgAsmCilAssemblyRefOSTable::p_elements};
39821 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39822 using bind = Desc<SgAsmCilAssemblyRefOSTable, std::vector<SgAsmCilAssemblyRefOS*> SgAsmCilAssemblyRefOSTable::*, &SgAsmCilAssemblyRefOSTable::p_elements>;
39823};
39826 using base = SgAsmCilMetadata;
39827 static constexpr char const * const name{"AsmCilAssemblyRefOSTable"};
39828 static constexpr unsigned long variant{1004};
39829 static constexpr bool concrete{true};
39830 using subclasses_t = mp::List<>;
39832};
39833template <> struct node_from_variant_t<1004> { using type = SgAsmCilAssemblyRefOSTable; };
39834
39835// Class: AsmCilAssemblyRefProcessorTable
39836template <> struct describe_field_t<SgAsmCilAssemblyRefProcessorTable,std::vector<SgAsmCilAssemblyRefProcessor*>,&SgAsmCilAssemblyRefProcessorTable::p_elements> {
39838 using field_type = std::vector<SgAsmCilAssemblyRefProcessor*>;
39839 static constexpr size_t position{0};
39840 static constexpr char const * const name{"elements"};
39841 static constexpr char const * const typestr{"std::vector<SgAsmCilAssemblyRefProcessor*>"};
39842 static constexpr bool traverse{true};
39843 static constexpr auto mbr_ptr{&SgAsmCilAssemblyRefProcessorTable::p_elements};
39844 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39845 using bind = Desc<SgAsmCilAssemblyRefProcessorTable, std::vector<SgAsmCilAssemblyRefProcessor*> SgAsmCilAssemblyRefProcessorTable::*, &SgAsmCilAssemblyRefProcessorTable::p_elements>;
39846};
39849 using base = SgAsmCilMetadata;
39850 static constexpr char const * const name{"AsmCilAssemblyRefProcessorTable"};
39851 static constexpr unsigned long variant{1005};
39852 static constexpr bool concrete{true};
39853 using subclasses_t = mp::List<>;
39855};
39856template <> struct node_from_variant_t<1005> { using type = SgAsmCilAssemblyRefProcessorTable; };
39857
39858// Class: AsmCilClassLayoutTable
39859template <> struct describe_field_t<SgAsmCilClassLayoutTable,std::vector<SgAsmCilClassLayout*>,&SgAsmCilClassLayoutTable::p_elements> {
39861 using field_type = std::vector<SgAsmCilClassLayout*>;
39862 static constexpr size_t position{0};
39863 static constexpr char const * const name{"elements"};
39864 static constexpr char const * const typestr{"std::vector<SgAsmCilClassLayout*>"};
39865 static constexpr bool traverse{true};
39866 static constexpr auto mbr_ptr{&SgAsmCilClassLayoutTable::p_elements};
39867 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39868 using bind = Desc<SgAsmCilClassLayoutTable, std::vector<SgAsmCilClassLayout*> SgAsmCilClassLayoutTable::*, &SgAsmCilClassLayoutTable::p_elements>;
39869};
39872 using base = SgAsmCilMetadata;
39873 static constexpr char const * const name{"AsmCilClassLayoutTable"};
39874 static constexpr unsigned long variant{1006};
39875 static constexpr bool concrete{true};
39876 using subclasses_t = mp::List<>;
39878};
39879template <> struct node_from_variant_t<1006> { using type = SgAsmCilClassLayoutTable; };
39880
39881// Class: AsmCilConstantTable
39882template <> struct describe_field_t<SgAsmCilConstantTable,std::vector<SgAsmCilConstant*>,&SgAsmCilConstantTable::p_elements> {
39884 using field_type = std::vector<SgAsmCilConstant*>;
39885 static constexpr size_t position{0};
39886 static constexpr char const * const name{"elements"};
39887 static constexpr char const * const typestr{"std::vector<SgAsmCilConstant*>"};
39888 static constexpr bool traverse{true};
39889 static constexpr auto mbr_ptr{&SgAsmCilConstantTable::p_elements};
39890 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39891 using bind = Desc<SgAsmCilConstantTable, std::vector<SgAsmCilConstant*> SgAsmCilConstantTable::*, &SgAsmCilConstantTable::p_elements>;
39892};
39895 using base = SgAsmCilMetadata;
39896 static constexpr char const * const name{"AsmCilConstantTable"};
39897 static constexpr unsigned long variant{1007};
39898 static constexpr bool concrete{true};
39899 using subclasses_t = mp::List<>;
39901};
39902template <> struct node_from_variant_t<1007> { using type = SgAsmCilConstantTable; };
39903
39904// Class: AsmCilCustomAttributeTable
39905template <> struct describe_field_t<SgAsmCilCustomAttributeTable,std::vector<SgAsmCilCustomAttribute*>,&SgAsmCilCustomAttributeTable::p_elements> {
39907 using field_type = std::vector<SgAsmCilCustomAttribute*>;
39908 static constexpr size_t position{0};
39909 static constexpr char const * const name{"elements"};
39910 static constexpr char const * const typestr{"std::vector<SgAsmCilCustomAttribute*>"};
39911 static constexpr bool traverse{true};
39912 static constexpr auto mbr_ptr{&SgAsmCilCustomAttributeTable::p_elements};
39913 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39914 using bind = Desc<SgAsmCilCustomAttributeTable, std::vector<SgAsmCilCustomAttribute*> SgAsmCilCustomAttributeTable::*, &SgAsmCilCustomAttributeTable::p_elements>;
39915};
39918 using base = SgAsmCilMetadata;
39919 static constexpr char const * const name{"AsmCilCustomAttributeTable"};
39920 static constexpr unsigned long variant{1008};
39921 static constexpr bool concrete{true};
39922 using subclasses_t = mp::List<>;
39924};
39925template <> struct node_from_variant_t<1008> { using type = SgAsmCilCustomAttributeTable; };
39926
39927// Class: AsmCilDeclSecurityTable
39928template <> struct describe_field_t<SgAsmCilDeclSecurityTable,std::vector<SgAsmCilDeclSecurity*>,&SgAsmCilDeclSecurityTable::p_elements> {
39930 using field_type = std::vector<SgAsmCilDeclSecurity*>;
39931 static constexpr size_t position{0};
39932 static constexpr char const * const name{"elements"};
39933 static constexpr char const * const typestr{"std::vector<SgAsmCilDeclSecurity*>"};
39934 static constexpr bool traverse{true};
39935 static constexpr auto mbr_ptr{&SgAsmCilDeclSecurityTable::p_elements};
39936 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39937 using bind = Desc<SgAsmCilDeclSecurityTable, std::vector<SgAsmCilDeclSecurity*> SgAsmCilDeclSecurityTable::*, &SgAsmCilDeclSecurityTable::p_elements>;
39938};
39941 using base = SgAsmCilMetadata;
39942 static constexpr char const * const name{"AsmCilDeclSecurityTable"};
39943 static constexpr unsigned long variant{1009};
39944 static constexpr bool concrete{true};
39945 using subclasses_t = mp::List<>;
39947};
39948template <> struct node_from_variant_t<1009> { using type = SgAsmCilDeclSecurityTable; };
39949
39950// Class: AsmCilEventTable
39951template <> struct describe_field_t<SgAsmCilEventTable,std::vector<SgAsmCilEvent*>,&SgAsmCilEventTable::p_elements> {
39952 using parent = SgAsmCilEventTable;
39953 using field_type = std::vector<SgAsmCilEvent*>;
39954 static constexpr size_t position{0};
39955 static constexpr char const * const name{"elements"};
39956 static constexpr char const * const typestr{"std::vector<SgAsmCilEvent*>"};
39957 static constexpr bool traverse{true};
39958 static constexpr auto mbr_ptr{&SgAsmCilEventTable::p_elements};
39959 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39960 using bind = Desc<SgAsmCilEventTable, std::vector<SgAsmCilEvent*> SgAsmCilEventTable::*, &SgAsmCilEventTable::p_elements>;
39961};
39963 using node = SgAsmCilEventTable;
39964 using base = SgAsmCilMetadata;
39965 static constexpr char const * const name{"AsmCilEventTable"};
39966 static constexpr unsigned long variant{1010};
39967 static constexpr bool concrete{true};
39968 using subclasses_t = mp::List<>;
39970};
39971template <> struct node_from_variant_t<1010> { using type = SgAsmCilEventTable; };
39972
39973// Class: AsmCilEventMapTable
39974template <> struct describe_field_t<SgAsmCilEventMapTable,std::vector<SgAsmCilEventMap*>,&SgAsmCilEventMapTable::p_elements> {
39976 using field_type = std::vector<SgAsmCilEventMap*>;
39977 static constexpr size_t position{0};
39978 static constexpr char const * const name{"elements"};
39979 static constexpr char const * const typestr{"std::vector<SgAsmCilEventMap*>"};
39980 static constexpr bool traverse{true};
39981 static constexpr auto mbr_ptr{&SgAsmCilEventMapTable::p_elements};
39982 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39983 using bind = Desc<SgAsmCilEventMapTable, std::vector<SgAsmCilEventMap*> SgAsmCilEventMapTable::*, &SgAsmCilEventMapTable::p_elements>;
39984};
39987 using base = SgAsmCilMetadata;
39988 static constexpr char const * const name{"AsmCilEventMapTable"};
39989 static constexpr unsigned long variant{1011};
39990 static constexpr bool concrete{true};
39991 using subclasses_t = mp::List<>;
39993};
39994template <> struct node_from_variant_t<1011> { using type = SgAsmCilEventMapTable; };
39995
39996// Class: AsmCilExportedTypeTable
39997template <> struct describe_field_t<SgAsmCilExportedTypeTable,std::vector<SgAsmCilExportedType*>,&SgAsmCilExportedTypeTable::p_elements> {
39999 using field_type = std::vector<SgAsmCilExportedType*>;
40000 static constexpr size_t position{0};
40001 static constexpr char const * const name{"elements"};
40002 static constexpr char const * const typestr{"std::vector<SgAsmCilExportedType*>"};
40003 static constexpr bool traverse{true};
40004 static constexpr auto mbr_ptr{&SgAsmCilExportedTypeTable::p_elements};
40005 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40006 using bind = Desc<SgAsmCilExportedTypeTable, std::vector<SgAsmCilExportedType*> SgAsmCilExportedTypeTable::*, &SgAsmCilExportedTypeTable::p_elements>;
40007};
40010 using base = SgAsmCilMetadata;
40011 static constexpr char const * const name{"AsmCilExportedTypeTable"};
40012 static constexpr unsigned long variant{1012};
40013 static constexpr bool concrete{true};
40014 using subclasses_t = mp::List<>;
40016};
40017template <> struct node_from_variant_t<1012> { using type = SgAsmCilExportedTypeTable; };
40018
40019// Class: AsmCilFieldTable
40020template <> struct describe_field_t<SgAsmCilFieldTable,std::vector<SgAsmCilField*>,&SgAsmCilFieldTable::p_elements> {
40021 using parent = SgAsmCilFieldTable;
40022 using field_type = std::vector<SgAsmCilField*>;
40023 static constexpr size_t position{0};
40024 static constexpr char const * const name{"elements"};
40025 static constexpr char const * const typestr{"std::vector<SgAsmCilField*>"};
40026 static constexpr bool traverse{true};
40027 static constexpr auto mbr_ptr{&SgAsmCilFieldTable::p_elements};
40028 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40029 using bind = Desc<SgAsmCilFieldTable, std::vector<SgAsmCilField*> SgAsmCilFieldTable::*, &SgAsmCilFieldTable::p_elements>;
40030};
40032 using node = SgAsmCilFieldTable;
40033 using base = SgAsmCilMetadata;
40034 static constexpr char const * const name{"AsmCilFieldTable"};
40035 static constexpr unsigned long variant{1013};
40036 static constexpr bool concrete{true};
40037 using subclasses_t = mp::List<>;
40039};
40040template <> struct node_from_variant_t<1013> { using type = SgAsmCilFieldTable; };
40041
40042// Class: AsmCilFieldLayoutTable
40043template <> struct describe_field_t<SgAsmCilFieldLayoutTable,std::vector<SgAsmCilFieldLayout*>,&SgAsmCilFieldLayoutTable::p_elements> {
40045 using field_type = std::vector<SgAsmCilFieldLayout*>;
40046 static constexpr size_t position{0};
40047 static constexpr char const * const name{"elements"};
40048 static constexpr char const * const typestr{"std::vector<SgAsmCilFieldLayout*>"};
40049 static constexpr bool traverse{true};
40050 static constexpr auto mbr_ptr{&SgAsmCilFieldLayoutTable::p_elements};
40051 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40052 using bind = Desc<SgAsmCilFieldLayoutTable, std::vector<SgAsmCilFieldLayout*> SgAsmCilFieldLayoutTable::*, &SgAsmCilFieldLayoutTable::p_elements>;
40053};
40056 using base = SgAsmCilMetadata;
40057 static constexpr char const * const name{"AsmCilFieldLayoutTable"};
40058 static constexpr unsigned long variant{1014};
40059 static constexpr bool concrete{true};
40060 using subclasses_t = mp::List<>;
40062};
40063template <> struct node_from_variant_t<1014> { using type = SgAsmCilFieldLayoutTable; };
40064
40065// Class: AsmCilFieldMarshalTable
40066template <> struct describe_field_t<SgAsmCilFieldMarshalTable,std::vector<SgAsmCilFieldMarshal*>,&SgAsmCilFieldMarshalTable::p_elements> {
40068 using field_type = std::vector<SgAsmCilFieldMarshal*>;
40069 static constexpr size_t position{0};
40070 static constexpr char const * const name{"elements"};
40071 static constexpr char const * const typestr{"std::vector<SgAsmCilFieldMarshal*>"};
40072 static constexpr bool traverse{true};
40073 static constexpr auto mbr_ptr{&SgAsmCilFieldMarshalTable::p_elements};
40074 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40075 using bind = Desc<SgAsmCilFieldMarshalTable, std::vector<SgAsmCilFieldMarshal*> SgAsmCilFieldMarshalTable::*, &SgAsmCilFieldMarshalTable::p_elements>;
40076};
40079 using base = SgAsmCilMetadata;
40080 static constexpr char const * const name{"AsmCilFieldMarshalTable"};
40081 static constexpr unsigned long variant{1015};
40082 static constexpr bool concrete{true};
40083 using subclasses_t = mp::List<>;
40085};
40086template <> struct node_from_variant_t<1015> { using type = SgAsmCilFieldMarshalTable; };
40087
40088// Class: AsmCilFieldRVATable
40089template <> struct describe_field_t<SgAsmCilFieldRVATable,std::vector<SgAsmCilFieldRVA*>,&SgAsmCilFieldRVATable::p_elements> {
40091 using field_type = std::vector<SgAsmCilFieldRVA*>;
40092 static constexpr size_t position{0};
40093 static constexpr char const * const name{"elements"};
40094 static constexpr char const * const typestr{"std::vector<SgAsmCilFieldRVA*>"};
40095 static constexpr bool traverse{true};
40096 static constexpr auto mbr_ptr{&SgAsmCilFieldRVATable::p_elements};
40097 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40098 using bind = Desc<SgAsmCilFieldRVATable, std::vector<SgAsmCilFieldRVA*> SgAsmCilFieldRVATable::*, &SgAsmCilFieldRVATable::p_elements>;
40099};
40102 using base = SgAsmCilMetadata;
40103 static constexpr char const * const name{"AsmCilFieldRVATable"};
40104 static constexpr unsigned long variant{1016};
40105 static constexpr bool concrete{true};
40106 using subclasses_t = mp::List<>;
40108};
40109template <> struct node_from_variant_t<1016> { using type = SgAsmCilFieldRVATable; };
40110
40111// Class: AsmCilFileTable
40112template <> struct describe_field_t<SgAsmCilFileTable,std::vector<SgAsmCilFile*>,&SgAsmCilFileTable::p_elements> {
40113 using parent = SgAsmCilFileTable;
40114 using field_type = std::vector<SgAsmCilFile*>;
40115 static constexpr size_t position{0};
40116 static constexpr char const * const name{"elements"};
40117 static constexpr char const * const typestr{"std::vector<SgAsmCilFile*>"};
40118 static constexpr bool traverse{true};
40119 static constexpr auto mbr_ptr{&SgAsmCilFileTable::p_elements};
40120 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40121 using bind = Desc<SgAsmCilFileTable, std::vector<SgAsmCilFile*> SgAsmCilFileTable::*, &SgAsmCilFileTable::p_elements>;
40122};
40124 using node = SgAsmCilFileTable;
40125 using base = SgAsmCilMetadata;
40126 static constexpr char const * const name{"AsmCilFileTable"};
40127 static constexpr unsigned long variant{1017};
40128 static constexpr bool concrete{true};
40129 using subclasses_t = mp::List<>;
40131};
40132template <> struct node_from_variant_t<1017> { using type = SgAsmCilFileTable; };
40133
40134// Class: AsmCilGenericParamTable
40135template <> struct describe_field_t<SgAsmCilGenericParamTable,std::vector<SgAsmCilGenericParam*>,&SgAsmCilGenericParamTable::p_elements> {
40137 using field_type = std::vector<SgAsmCilGenericParam*>;
40138 static constexpr size_t position{0};
40139 static constexpr char const * const name{"elements"};
40140 static constexpr char const * const typestr{"std::vector<SgAsmCilGenericParam*>"};
40141 static constexpr bool traverse{true};
40142 static constexpr auto mbr_ptr{&SgAsmCilGenericParamTable::p_elements};
40143 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40144 using bind = Desc<SgAsmCilGenericParamTable, std::vector<SgAsmCilGenericParam*> SgAsmCilGenericParamTable::*, &SgAsmCilGenericParamTable::p_elements>;
40145};
40148 using base = SgAsmCilMetadata;
40149 static constexpr char const * const name{"AsmCilGenericParamTable"};
40150 static constexpr unsigned long variant{1018};
40151 static constexpr bool concrete{true};
40152 using subclasses_t = mp::List<>;
40154};
40155template <> struct node_from_variant_t<1018> { using type = SgAsmCilGenericParamTable; };
40156
40157// Class: AsmCilGenericParamConstraintTable
40158template <> struct describe_field_t<SgAsmCilGenericParamConstraintTable,std::vector<SgAsmCilGenericParamConstraint*>,&SgAsmCilGenericParamConstraintTable::p_elements> {
40160 using field_type = std::vector<SgAsmCilGenericParamConstraint*>;
40161 static constexpr size_t position{0};
40162 static constexpr char const * const name{"elements"};
40163 static constexpr char const * const typestr{"std::vector<SgAsmCilGenericParamConstraint*>"};
40164 static constexpr bool traverse{true};
40165 static constexpr auto mbr_ptr{&SgAsmCilGenericParamConstraintTable::p_elements};
40166 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40167 using bind = Desc<SgAsmCilGenericParamConstraintTable, std::vector<SgAsmCilGenericParamConstraint*> SgAsmCilGenericParamConstraintTable::*, &SgAsmCilGenericParamConstraintTable::p_elements>;
40168};
40171 using base = SgAsmCilMetadata;
40172 static constexpr char const * const name{"AsmCilGenericParamConstraintTable"};
40173 static constexpr unsigned long variant{1019};
40174 static constexpr bool concrete{true};
40175 using subclasses_t = mp::List<>;
40177};
40178template <> struct node_from_variant_t<1019> { using type = SgAsmCilGenericParamConstraintTable; };
40179
40180// Class: AsmCilImplMapTable
40181template <> struct describe_field_t<SgAsmCilImplMapTable,std::vector<SgAsmCilImplMap*>,&SgAsmCilImplMapTable::p_elements> {
40183 using field_type = std::vector<SgAsmCilImplMap*>;
40184 static constexpr size_t position{0};
40185 static constexpr char const * const name{"elements"};
40186 static constexpr char const * const typestr{"std::vector<SgAsmCilImplMap*>"};
40187 static constexpr bool traverse{true};
40188 static constexpr auto mbr_ptr{&SgAsmCilImplMapTable::p_elements};
40189 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40190 using bind = Desc<SgAsmCilImplMapTable, std::vector<SgAsmCilImplMap*> SgAsmCilImplMapTable::*, &SgAsmCilImplMapTable::p_elements>;
40191};
40193 using node = SgAsmCilImplMapTable;
40194 using base = SgAsmCilMetadata;
40195 static constexpr char const * const name{"AsmCilImplMapTable"};
40196 static constexpr unsigned long variant{1020};
40197 static constexpr bool concrete{true};
40198 using subclasses_t = mp::List<>;
40200};
40201template <> struct node_from_variant_t<1020> { using type = SgAsmCilImplMapTable; };
40202
40203// Class: AsmCilInterfaceImplTable
40204template <> struct describe_field_t<SgAsmCilInterfaceImplTable,std::vector<SgAsmCilInterfaceImpl*>,&SgAsmCilInterfaceImplTable::p_elements> {
40206 using field_type = std::vector<SgAsmCilInterfaceImpl*>;
40207 static constexpr size_t position{0};
40208 static constexpr char const * const name{"elements"};
40209 static constexpr char const * const typestr{"std::vector<SgAsmCilInterfaceImpl*>"};
40210 static constexpr bool traverse{true};
40211 static constexpr auto mbr_ptr{&SgAsmCilInterfaceImplTable::p_elements};
40212 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40213 using bind = Desc<SgAsmCilInterfaceImplTable, std::vector<SgAsmCilInterfaceImpl*> SgAsmCilInterfaceImplTable::*, &SgAsmCilInterfaceImplTable::p_elements>;
40214};
40217 using base = SgAsmCilMetadata;
40218 static constexpr char const * const name{"AsmCilInterfaceImplTable"};
40219 static constexpr unsigned long variant{1021};
40220 static constexpr bool concrete{true};
40221 using subclasses_t = mp::List<>;
40223};
40224template <> struct node_from_variant_t<1021> { using type = SgAsmCilInterfaceImplTable; };
40225
40226// Class: AsmCilManifestResourceTable
40227template <> struct describe_field_t<SgAsmCilManifestResourceTable,std::vector<SgAsmCilManifestResource*>,&SgAsmCilManifestResourceTable::p_elements> {
40229 using field_type = std::vector<SgAsmCilManifestResource*>;
40230 static constexpr size_t position{0};
40231 static constexpr char const * const name{"elements"};
40232 static constexpr char const * const typestr{"std::vector<SgAsmCilManifestResource*>"};
40233 static constexpr bool traverse{true};
40234 static constexpr auto mbr_ptr{&SgAsmCilManifestResourceTable::p_elements};
40235 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40236 using bind = Desc<SgAsmCilManifestResourceTable, std::vector<SgAsmCilManifestResource*> SgAsmCilManifestResourceTable::*, &SgAsmCilManifestResourceTable::p_elements>;
40237};
40240 using base = SgAsmCilMetadata;
40241 static constexpr char const * const name{"AsmCilManifestResourceTable"};
40242 static constexpr unsigned long variant{1022};
40243 static constexpr bool concrete{true};
40244 using subclasses_t = mp::List<>;
40246};
40247template <> struct node_from_variant_t<1022> { using type = SgAsmCilManifestResourceTable; };
40248
40249// Class: AsmCilMemberRefTable
40250template <> struct describe_field_t<SgAsmCilMemberRefTable,std::vector<SgAsmCilMemberRef*>,&SgAsmCilMemberRefTable::p_elements> {
40252 using field_type = std::vector<SgAsmCilMemberRef*>;
40253 static constexpr size_t position{0};
40254 static constexpr char const * const name{"elements"};
40255 static constexpr char const * const typestr{"std::vector<SgAsmCilMemberRef*>"};
40256 static constexpr bool traverse{true};
40257 static constexpr auto mbr_ptr{&SgAsmCilMemberRefTable::p_elements};
40258 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40259 using bind = Desc<SgAsmCilMemberRefTable, std::vector<SgAsmCilMemberRef*> SgAsmCilMemberRefTable::*, &SgAsmCilMemberRefTable::p_elements>;
40260};
40263 using base = SgAsmCilMetadata;
40264 static constexpr char const * const name{"AsmCilMemberRefTable"};
40265 static constexpr unsigned long variant{1023};
40266 static constexpr bool concrete{true};
40267 using subclasses_t = mp::List<>;
40269};
40270template <> struct node_from_variant_t<1023> { using type = SgAsmCilMemberRefTable; };
40271
40272// Class: AsmCilMethodDefTable
40273template <> struct describe_field_t<SgAsmCilMethodDefTable,std::vector<SgAsmCilMethodDef*>,&SgAsmCilMethodDefTable::p_elements> {
40275 using field_type = std::vector<SgAsmCilMethodDef*>;
40276 static constexpr size_t position{0};
40277 static constexpr char const * const name{"elements"};
40278 static constexpr char const * const typestr{"std::vector<SgAsmCilMethodDef*>"};
40279 static constexpr bool traverse{true};
40280 static constexpr auto mbr_ptr{&SgAsmCilMethodDefTable::p_elements};
40281 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40282 using bind = Desc<SgAsmCilMethodDefTable, std::vector<SgAsmCilMethodDef*> SgAsmCilMethodDefTable::*, &SgAsmCilMethodDefTable::p_elements>;
40283};
40286 using base = SgAsmCilMetadata;
40287 static constexpr char const * const name{"AsmCilMethodDefTable"};
40288 static constexpr unsigned long variant{1024};
40289 static constexpr bool concrete{true};
40290 using subclasses_t = mp::List<>;
40292};
40293template <> struct node_from_variant_t<1024> { using type = SgAsmCilMethodDefTable; };
40294
40295// Class: AsmCilMethodImplTable
40296template <> struct describe_field_t<SgAsmCilMethodImplTable,std::vector<SgAsmCilMethodImpl*>,&SgAsmCilMethodImplTable::p_elements> {
40298 using field_type = std::vector<SgAsmCilMethodImpl*>;
40299 static constexpr size_t position{0};
40300 static constexpr char const * const name{"elements"};
40301 static constexpr char const * const typestr{"std::vector<SgAsmCilMethodImpl*>"};
40302 static constexpr bool traverse{true};
40303 static constexpr auto mbr_ptr{&SgAsmCilMethodImplTable::p_elements};
40304 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40305 using bind = Desc<SgAsmCilMethodImplTable, std::vector<SgAsmCilMethodImpl*> SgAsmCilMethodImplTable::*, &SgAsmCilMethodImplTable::p_elements>;
40306};
40309 using base = SgAsmCilMetadata;
40310 static constexpr char const * const name{"AsmCilMethodImplTable"};
40311 static constexpr unsigned long variant{1025};
40312 static constexpr bool concrete{true};
40313 using subclasses_t = mp::List<>;
40315};
40316template <> struct node_from_variant_t<1025> { using type = SgAsmCilMethodImplTable; };
40317
40318// Class: AsmCilMethodSemanticsTable
40319template <> struct describe_field_t<SgAsmCilMethodSemanticsTable,std::vector<SgAsmCilMethodSemantics*>,&SgAsmCilMethodSemanticsTable::p_elements> {
40321 using field_type = std::vector<SgAsmCilMethodSemantics*>;
40322 static constexpr size_t position{0};
40323 static constexpr char const * const name{"elements"};
40324 static constexpr char const * const typestr{"std::vector<SgAsmCilMethodSemantics*>"};
40325 static constexpr bool traverse{true};
40326 static constexpr auto mbr_ptr{&SgAsmCilMethodSemanticsTable::p_elements};
40327 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40328 using bind = Desc<SgAsmCilMethodSemanticsTable, std::vector<SgAsmCilMethodSemantics*> SgAsmCilMethodSemanticsTable::*, &SgAsmCilMethodSemanticsTable::p_elements>;
40329};
40332 using base = SgAsmCilMetadata;
40333 static constexpr char const * const name{"AsmCilMethodSemanticsTable"};
40334 static constexpr unsigned long variant{1026};
40335 static constexpr bool concrete{true};
40336 using subclasses_t = mp::List<>;
40338};
40339template <> struct node_from_variant_t<1026> { using type = SgAsmCilMethodSemanticsTable; };
40340
40341// Class: AsmCilMethodSpecTable
40342template <> struct describe_field_t<SgAsmCilMethodSpecTable,std::vector<SgAsmCilMethodSpec*>,&SgAsmCilMethodSpecTable::p_elements> {
40344 using field_type = std::vector<SgAsmCilMethodSpec*>;
40345 static constexpr size_t position{0};
40346 static constexpr char const * const name{"elements"};
40347 static constexpr char const * const typestr{"std::vector<SgAsmCilMethodSpec*>"};
40348 static constexpr bool traverse{true};
40349 static constexpr auto mbr_ptr{&SgAsmCilMethodSpecTable::p_elements};
40350 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40351 using bind = Desc<SgAsmCilMethodSpecTable, std::vector<SgAsmCilMethodSpec*> SgAsmCilMethodSpecTable::*, &SgAsmCilMethodSpecTable::p_elements>;
40352};
40355 using base = SgAsmCilMetadata;
40356 static constexpr char const * const name{"AsmCilMethodSpecTable"};
40357 static constexpr unsigned long variant{1027};
40358 static constexpr bool concrete{true};
40359 using subclasses_t = mp::List<>;
40361};
40362template <> struct node_from_variant_t<1027> { using type = SgAsmCilMethodSpecTable; };
40363
40364// Class: AsmCilModuleTable
40365template <> struct describe_field_t<SgAsmCilModuleTable,std::vector<SgAsmCilModule*>,&SgAsmCilModuleTable::p_elements> {
40367 using field_type = std::vector<SgAsmCilModule*>;
40368 static constexpr size_t position{0};
40369 static constexpr char const * const name{"elements"};
40370 static constexpr char const * const typestr{"std::vector<SgAsmCilModule*>"};
40371 static constexpr bool traverse{true};
40372 static constexpr auto mbr_ptr{&SgAsmCilModuleTable::p_elements};
40373 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40374 using bind = Desc<SgAsmCilModuleTable, std::vector<SgAsmCilModule*> SgAsmCilModuleTable::*, &SgAsmCilModuleTable::p_elements>;
40375};
40377 using node = SgAsmCilModuleTable;
40378 using base = SgAsmCilMetadata;
40379 static constexpr char const * const name{"AsmCilModuleTable"};
40380 static constexpr unsigned long variant{1028};
40381 static constexpr bool concrete{true};
40382 using subclasses_t = mp::List<>;
40384};
40385template <> struct node_from_variant_t<1028> { using type = SgAsmCilModuleTable; };
40386
40387// Class: AsmCilModuleRefTable
40388template <> struct describe_field_t<SgAsmCilModuleRefTable,std::vector<SgAsmCilModuleRef*>,&SgAsmCilModuleRefTable::p_elements> {
40390 using field_type = std::vector<SgAsmCilModuleRef*>;
40391 static constexpr size_t position{0};
40392 static constexpr char const * const name{"elements"};
40393 static constexpr char const * const typestr{"std::vector<SgAsmCilModuleRef*>"};
40394 static constexpr bool traverse{true};
40395 static constexpr auto mbr_ptr{&SgAsmCilModuleRefTable::p_elements};
40396 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40397 using bind = Desc<SgAsmCilModuleRefTable, std::vector<SgAsmCilModuleRef*> SgAsmCilModuleRefTable::*, &SgAsmCilModuleRefTable::p_elements>;
40398};
40401 using base = SgAsmCilMetadata;
40402 static constexpr char const * const name{"AsmCilModuleRefTable"};
40403 static constexpr unsigned long variant{1029};
40404 static constexpr bool concrete{true};
40405 using subclasses_t = mp::List<>;
40407};
40408template <> struct node_from_variant_t<1029> { using type = SgAsmCilModuleRefTable; };
40409
40410// Class: AsmCilNestedClassTable
40411template <> struct describe_field_t<SgAsmCilNestedClassTable,std::vector<SgAsmCilNestedClass*>,&SgAsmCilNestedClassTable::p_elements> {
40413 using field_type = std::vector<SgAsmCilNestedClass*>;
40414 static constexpr size_t position{0};
40415 static constexpr char const * const name{"elements"};
40416 static constexpr char const * const typestr{"std::vector<SgAsmCilNestedClass*>"};
40417 static constexpr bool traverse{true};
40418 static constexpr auto mbr_ptr{&SgAsmCilNestedClassTable::p_elements};
40419 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40420 using bind = Desc<SgAsmCilNestedClassTable, std::vector<SgAsmCilNestedClass*> SgAsmCilNestedClassTable::*, &SgAsmCilNestedClassTable::p_elements>;
40421};
40424 using base = SgAsmCilMetadata;
40425 static constexpr char const * const name{"AsmCilNestedClassTable"};
40426 static constexpr unsigned long variant{1030};
40427 static constexpr bool concrete{true};
40428 using subclasses_t = mp::List<>;
40430};
40431template <> struct node_from_variant_t<1030> { using type = SgAsmCilNestedClassTable; };
40432
40433// Class: AsmCilParamTable
40434template <> struct describe_field_t<SgAsmCilParamTable,std::vector<SgAsmCilParam*>,&SgAsmCilParamTable::p_elements> {
40435 using parent = SgAsmCilParamTable;
40436 using field_type = std::vector<SgAsmCilParam*>;
40437 static constexpr size_t position{0};
40438 static constexpr char const * const name{"elements"};
40439 static constexpr char const * const typestr{"std::vector<SgAsmCilParam*>"};
40440 static constexpr bool traverse{true};
40441 static constexpr auto mbr_ptr{&SgAsmCilParamTable::p_elements};
40442 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40443 using bind = Desc<SgAsmCilParamTable, std::vector<SgAsmCilParam*> SgAsmCilParamTable::*, &SgAsmCilParamTable::p_elements>;
40444};
40446 using node = SgAsmCilParamTable;
40447 using base = SgAsmCilMetadata;
40448 static constexpr char const * const name{"AsmCilParamTable"};
40449 static constexpr unsigned long variant{1031};
40450 static constexpr bool concrete{true};
40451 using subclasses_t = mp::List<>;
40453};
40454template <> struct node_from_variant_t<1031> { using type = SgAsmCilParamTable; };
40455
40456// Class: AsmCilPropertyTable
40457template <> struct describe_field_t<SgAsmCilPropertyTable,std::vector<SgAsmCilProperty*>,&SgAsmCilPropertyTable::p_elements> {
40459 using field_type = std::vector<SgAsmCilProperty*>;
40460 static constexpr size_t position{0};
40461 static constexpr char const * const name{"elements"};
40462 static constexpr char const * const typestr{"std::vector<SgAsmCilProperty*>"};
40463 static constexpr bool traverse{true};
40464 static constexpr auto mbr_ptr{&SgAsmCilPropertyTable::p_elements};
40465 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40466 using bind = Desc<SgAsmCilPropertyTable, std::vector<SgAsmCilProperty*> SgAsmCilPropertyTable::*, &SgAsmCilPropertyTable::p_elements>;
40467};
40470 using base = SgAsmCilMetadata;
40471 static constexpr char const * const name{"AsmCilPropertyTable"};
40472 static constexpr unsigned long variant{1032};
40473 static constexpr bool concrete{true};
40474 using subclasses_t = mp::List<>;
40476};
40477template <> struct node_from_variant_t<1032> { using type = SgAsmCilPropertyTable; };
40478
40479// Class: AsmCilPropertyMapTable
40480template <> struct describe_field_t<SgAsmCilPropertyMapTable,std::vector<SgAsmCilPropertyMap*>,&SgAsmCilPropertyMapTable::p_elements> {
40482 using field_type = std::vector<SgAsmCilPropertyMap*>;
40483 static constexpr size_t position{0};
40484 static constexpr char const * const name{"elements"};
40485 static constexpr char const * const typestr{"std::vector<SgAsmCilPropertyMap*>"};
40486 static constexpr bool traverse{true};
40487 static constexpr auto mbr_ptr{&SgAsmCilPropertyMapTable::p_elements};
40488 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40489 using bind = Desc<SgAsmCilPropertyMapTable, std::vector<SgAsmCilPropertyMap*> SgAsmCilPropertyMapTable::*, &SgAsmCilPropertyMapTable::p_elements>;
40490};
40493 using base = SgAsmCilMetadata;
40494 static constexpr char const * const name{"AsmCilPropertyMapTable"};
40495 static constexpr unsigned long variant{1033};
40496 static constexpr bool concrete{true};
40497 using subclasses_t = mp::List<>;
40499};
40500template <> struct node_from_variant_t<1033> { using type = SgAsmCilPropertyMapTable; };
40501
40502// Class: AsmCilStandAloneSigTable
40503template <> struct describe_field_t<SgAsmCilStandAloneSigTable,std::vector<SgAsmCilStandAloneSig*>,&SgAsmCilStandAloneSigTable::p_elements> {
40505 using field_type = std::vector<SgAsmCilStandAloneSig*>;
40506 static constexpr size_t position{0};
40507 static constexpr char const * const name{"elements"};
40508 static constexpr char const * const typestr{"std::vector<SgAsmCilStandAloneSig*>"};
40509 static constexpr bool traverse{true};
40510 static constexpr auto mbr_ptr{&SgAsmCilStandAloneSigTable::p_elements};
40511 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40512 using bind = Desc<SgAsmCilStandAloneSigTable, std::vector<SgAsmCilStandAloneSig*> SgAsmCilStandAloneSigTable::*, &SgAsmCilStandAloneSigTable::p_elements>;
40513};
40516 using base = SgAsmCilMetadata;
40517 static constexpr char const * const name{"AsmCilStandAloneSigTable"};
40518 static constexpr unsigned long variant{1034};
40519 static constexpr bool concrete{true};
40520 using subclasses_t = mp::List<>;
40522};
40523template <> struct node_from_variant_t<1034> { using type = SgAsmCilStandAloneSigTable; };
40524
40525// Class: AsmCilTypeDefTable
40526template <> struct describe_field_t<SgAsmCilTypeDefTable,std::vector<SgAsmCilTypeDef*>,&SgAsmCilTypeDefTable::p_elements> {
40528 using field_type = std::vector<SgAsmCilTypeDef*>;
40529 static constexpr size_t position{0};
40530 static constexpr char const * const name{"elements"};
40531 static constexpr char const * const typestr{"std::vector<SgAsmCilTypeDef*>"};
40532 static constexpr bool traverse{true};
40533 static constexpr auto mbr_ptr{&SgAsmCilTypeDefTable::p_elements};
40534 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40535 using bind = Desc<SgAsmCilTypeDefTable, std::vector<SgAsmCilTypeDef*> SgAsmCilTypeDefTable::*, &SgAsmCilTypeDefTable::p_elements>;
40536};
40538 using node = SgAsmCilTypeDefTable;
40539 using base = SgAsmCilMetadata;
40540 static constexpr char const * const name{"AsmCilTypeDefTable"};
40541 static constexpr unsigned long variant{1035};
40542 static constexpr bool concrete{true};
40543 using subclasses_t = mp::List<>;
40545};
40546template <> struct node_from_variant_t<1035> { using type = SgAsmCilTypeDefTable; };
40547
40548// Class: AsmCilTypeRefTable
40549template <> struct describe_field_t<SgAsmCilTypeRefTable,std::vector<SgAsmCilTypeRef*>,&SgAsmCilTypeRefTable::p_elements> {
40551 using field_type = std::vector<SgAsmCilTypeRef*>;
40552 static constexpr size_t position{0};
40553 static constexpr char const * const name{"elements"};
40554 static constexpr char const * const typestr{"std::vector<SgAsmCilTypeRef*>"};
40555 static constexpr bool traverse{true};
40556 static constexpr auto mbr_ptr{&SgAsmCilTypeRefTable::p_elements};
40557 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40558 using bind = Desc<SgAsmCilTypeRefTable, std::vector<SgAsmCilTypeRef*> SgAsmCilTypeRefTable::*, &SgAsmCilTypeRefTable::p_elements>;
40559};
40561 using node = SgAsmCilTypeRefTable;
40562 using base = SgAsmCilMetadata;
40563 static constexpr char const * const name{"AsmCilTypeRefTable"};
40564 static constexpr unsigned long variant{1036};
40565 static constexpr bool concrete{true};
40566 using subclasses_t = mp::List<>;
40568};
40569template <> struct node_from_variant_t<1036> { using type = SgAsmCilTypeRefTable; };
40570
40571// Class: AsmCilTypeSpecTable
40572template <> struct describe_field_t<SgAsmCilTypeSpecTable,std::vector<SgAsmCilTypeSpec*>,&SgAsmCilTypeSpecTable::p_elements> {
40574 using field_type = std::vector<SgAsmCilTypeSpec*>;
40575 static constexpr size_t position{0};
40576 static constexpr char const * const name{"elements"};
40577 static constexpr char const * const typestr{"std::vector<SgAsmCilTypeSpec*>"};
40578 static constexpr bool traverse{true};
40579 static constexpr auto mbr_ptr{&SgAsmCilTypeSpecTable::p_elements};
40580 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40581 using bind = Desc<SgAsmCilTypeSpecTable, std::vector<SgAsmCilTypeSpec*> SgAsmCilTypeSpecTable::*, &SgAsmCilTypeSpecTable::p_elements>;
40582};
40585 using base = SgAsmCilMetadata;
40586 static constexpr char const * const name{"AsmCilTypeSpecTable"};
40587 static constexpr unsigned long variant{1037};
40588 static constexpr bool concrete{true};
40589 using subclasses_t = mp::List<>;
40591};
40592template <> struct node_from_variant_t<1037> { using type = SgAsmCilTypeSpecTable; };
40593
40594// Class: JvmComposite
40595template <> struct describe_node_t<SgJvmComposite> {
40596 using node = SgJvmComposite;
40597 using base = SgBinaryComposite;
40598 static constexpr char const * const name{"JvmComposite"};
40599 static constexpr unsigned long variant{1038};
40600 static constexpr bool concrete{true};
40601 using subclasses_t = mp::List<>;
40602 using fields_t = mp::List<>;
40603};
40604template <> struct node_from_variant_t<1038> { using type = SgJvmComposite; };
40605
40606// Class: FortranContinueStmt
40609 using base = SgStatement;
40610 static constexpr char const * const name{"FortranContinueStmt"};
40611 static constexpr unsigned long variant{1039};
40612 static constexpr bool concrete{true};
40613 using subclasses_t = mp::List<>;
40614 using fields_t = mp::List<>;
40615};
40616template <> struct node_from_variant_t<1039> { using type = SgFortranContinueStmt; };
40617
40618// Class: AsmJvmStackMapTable
40619template <> struct describe_field_t<SgAsmJvmStackMapTable,SgAsmJvmStackMapFramePtrList,&SgAsmJvmStackMapTable::p_entries> {
40621 using field_type = SgAsmJvmStackMapFramePtrList;
40622 static constexpr size_t position{0};
40623 static constexpr char const * const name{"entries"};
40624 static constexpr char const * const typestr{"SgAsmJvmStackMapFramePtrList"};
40625 static constexpr bool traverse{false};
40626 static constexpr auto mbr_ptr{&SgAsmJvmStackMapTable::p_entries};
40627 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40628 using bind = Desc<SgAsmJvmStackMapTable, SgAsmJvmStackMapFramePtrList SgAsmJvmStackMapTable::*, &SgAsmJvmStackMapTable::p_entries>;
40629};
40632 using base = SgAsmJvmAttribute;
40633 static constexpr char const * const name{"AsmJvmStackMapTable"};
40634 static constexpr unsigned long variant{1040};
40635 static constexpr bool concrete{true};
40636 using subclasses_t = mp::List<>;
40638};
40639template <> struct node_from_variant_t<1040> { using type = SgAsmJvmStackMapTable; };
40640
40641// Class: AsmJvmStackMapFrame
40642template <> struct describe_field_t<SgAsmJvmStackMapFrame,SgAsmJvmStackMapVerificationTypePtrList,&SgAsmJvmStackMapFrame::p_stack> {
40644 using field_type = SgAsmJvmStackMapVerificationTypePtrList;
40645 static constexpr size_t position{0};
40646 static constexpr char const * const name{"stack"};
40647 static constexpr char const * const typestr{"SgAsmJvmStackMapVerificationTypePtrList"};
40648 static constexpr bool traverse{false};
40649 static constexpr auto mbr_ptr{&SgAsmJvmStackMapFrame::p_stack};
40650 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40651 using bind = Desc<SgAsmJvmStackMapFrame, SgAsmJvmStackMapVerificationTypePtrList SgAsmJvmStackMapFrame::*, &SgAsmJvmStackMapFrame::p_stack>;
40652};
40653template <> struct describe_field_t<SgAsmJvmStackMapFrame,SgAsmJvmStackMapVerificationTypePtrList,&SgAsmJvmStackMapFrame::p_locals> {
40655 using field_type = SgAsmJvmStackMapVerificationTypePtrList;
40656 static constexpr size_t position{1};
40657 static constexpr char const * const name{"locals"};
40658 static constexpr char const * const typestr{"SgAsmJvmStackMapVerificationTypePtrList"};
40659 static constexpr bool traverse{false};
40660 static constexpr auto mbr_ptr{&SgAsmJvmStackMapFrame::p_locals};
40661 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40662 using bind = Desc<SgAsmJvmStackMapFrame, SgAsmJvmStackMapVerificationTypePtrList SgAsmJvmStackMapFrame::*, &SgAsmJvmStackMapFrame::p_locals>;
40663};
40664template <> struct describe_field_t<SgAsmJvmStackMapFrame,uint8_t,&SgAsmJvmStackMapFrame::p_frame_type> {
40666 using field_type = uint8_t;
40667 static constexpr size_t position{2};
40668 static constexpr char const * const name{"frame_type"};
40669 static constexpr char const * const typestr{"uint8_t"};
40670 static constexpr bool traverse{false};
40671 static constexpr auto mbr_ptr{&SgAsmJvmStackMapFrame::p_frame_type};
40672 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40673 using bind = Desc<SgAsmJvmStackMapFrame, uint8_t SgAsmJvmStackMapFrame::*, &SgAsmJvmStackMapFrame::p_frame_type>;
40674};
40675template <> struct describe_field_t<SgAsmJvmStackMapFrame,uint16_t,&SgAsmJvmStackMapFrame::p_offset_delta> {
40677 using field_type = uint16_t;
40678 static constexpr size_t position{3};
40679 static constexpr char const * const name{"offset_delta"};
40680 static constexpr char const * const typestr{"uint16_t"};
40681 static constexpr bool traverse{false};
40682 static constexpr auto mbr_ptr{&SgAsmJvmStackMapFrame::p_offset_delta};
40683 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40684 using bind = Desc<SgAsmJvmStackMapFrame, uint16_t SgAsmJvmStackMapFrame::*, &SgAsmJvmStackMapFrame::p_offset_delta>;
40685};
40695template <> struct node_from_variant_t<1041> { using type = SgAsmJvmStackMapFrame; };
40696
40697// Class: AsmJvmStackMapVerificationType
40698template <> struct describe_field_t<SgAsmJvmStackMapVerificationType,uint8_t,&SgAsmJvmStackMapVerificationType::p_tag> {
40700 using field_type = uint8_t;
40701 static constexpr size_t position{0};
40702 static constexpr char const * const name{"tag"};
40703 static constexpr char const * const typestr{"uint8_t"};
40704 static constexpr bool traverse{false};
40705 static constexpr auto mbr_ptr{&SgAsmJvmStackMapVerificationType::p_tag};
40706 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40707 using bind = Desc<SgAsmJvmStackMapVerificationType, uint8_t SgAsmJvmStackMapVerificationType::*, &SgAsmJvmStackMapVerificationType::p_tag>;
40708};
40709template <> struct describe_field_t<SgAsmJvmStackMapVerificationType,uint16_t,&SgAsmJvmStackMapVerificationType::p_cpool_index> {
40711 using field_type = uint16_t;
40712 static constexpr size_t position{1};
40713 static constexpr char const * const name{"cpool_index"};
40714 static constexpr char const * const typestr{"uint16_t"};
40715 static constexpr bool traverse{false};
40716 static constexpr auto mbr_ptr{&SgAsmJvmStackMapVerificationType::p_cpool_index};
40717 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40718 using bind = Desc<SgAsmJvmStackMapVerificationType, uint16_t SgAsmJvmStackMapVerificationType::*, &SgAsmJvmStackMapVerificationType::p_cpool_index>;
40719};
40720template <> struct describe_field_t<SgAsmJvmStackMapVerificationType,uint16_t,&SgAsmJvmStackMapVerificationType::p_offset> {
40722 using field_type = uint16_t;
40723 static constexpr size_t position{2};
40724 static constexpr char const * const name{"offset"};
40725 static constexpr char const * const typestr{"uint16_t"};
40726 static constexpr bool traverse{false};
40727 static constexpr auto mbr_ptr{&SgAsmJvmStackMapVerificationType::p_offset};
40728 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40729 using bind = Desc<SgAsmJvmStackMapVerificationType, uint16_t SgAsmJvmStackMapVerificationType::*, &SgAsmJvmStackMapVerificationType::p_offset>;
40730};
40740template <> struct node_from_variant_t<1042> { using type = SgAsmJvmStackMapVerificationType; };
40741
40742// Class: AsmJvmBootstrapMethod
40743template <> struct describe_field_t<SgAsmJvmBootstrapMethod,uint16_t,&SgAsmJvmBootstrapMethod::p_bootstrap_method_ref> {
40745 using field_type = uint16_t;
40746 static constexpr size_t position{0};
40747 static constexpr char const * const name{"bootstrap_method_ref"};
40748 static constexpr char const * const typestr{"uint16_t"};
40749 static constexpr bool traverse{false};
40750 static constexpr auto mbr_ptr{&SgAsmJvmBootstrapMethod::p_bootstrap_method_ref};
40751 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40752 using bind = Desc<SgAsmJvmBootstrapMethod, uint16_t SgAsmJvmBootstrapMethod::*, &SgAsmJvmBootstrapMethod::p_bootstrap_method_ref>;
40753};
40754template <> struct describe_field_t<SgAsmJvmBootstrapMethod,SgUnsigned16List,&SgAsmJvmBootstrapMethod::p_bootstrap_arguments> {
40756 using field_type = SgUnsigned16List;
40757 static constexpr size_t position{1};
40758 static constexpr char const * const name{"bootstrap_arguments"};
40759 static constexpr char const * const typestr{"SgUnsigned16List"};
40760 static constexpr bool traverse{false};
40761 static constexpr auto mbr_ptr{&SgAsmJvmBootstrapMethod::p_bootstrap_arguments};
40762 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40763 using bind = Desc<SgAsmJvmBootstrapMethod, SgUnsigned16List SgAsmJvmBootstrapMethod::*, &SgAsmJvmBootstrapMethod::p_bootstrap_arguments>;
40764};
40767 using base = SgAsmJvmNode;
40768 static constexpr char const * const name{"AsmJvmBootstrapMethod"};
40769 static constexpr unsigned long variant{1043};
40770 static constexpr bool concrete{true};
40771 using subclasses_t = mp::List<>;
40773};
40774template <> struct node_from_variant_t<1043> { using type = SgAsmJvmBootstrapMethod; };
40775
40776// Class: AsmJvmBootstrapMethods
40777template <> struct describe_field_t<SgAsmJvmBootstrapMethods,SgAsmJvmBootstrapMethodPtrList,&SgAsmJvmBootstrapMethods::p_bootstrap_methods> {
40779 using field_type = SgAsmJvmBootstrapMethodPtrList;
40780 static constexpr size_t position{0};
40781 static constexpr char const * const name{"bootstrap_methods"};
40782 static constexpr char const * const typestr{"SgAsmJvmBootstrapMethodPtrList"};
40783 static constexpr bool traverse{false};
40784 static constexpr auto mbr_ptr{&SgAsmJvmBootstrapMethods::p_bootstrap_methods};
40785 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40786 using bind = Desc<SgAsmJvmBootstrapMethods, SgAsmJvmBootstrapMethodPtrList SgAsmJvmBootstrapMethods::*, &SgAsmJvmBootstrapMethods::p_bootstrap_methods>;
40787};
40790 using base = SgAsmJvmAttribute;
40791 static constexpr char const * const name{"AsmJvmBootstrapMethods"};
40792 static constexpr unsigned long variant{1044};
40793 static constexpr bool concrete{true};
40794 using subclasses_t = mp::List<>;
40796};
40797template <> struct node_from_variant_t<1044> { using type = SgAsmJvmBootstrapMethods; };
40798
40799// Class: AsmJvmExceptions
40800template <> struct describe_field_t<SgAsmJvmExceptions,SgUnsigned16List,&SgAsmJvmExceptions::p_exception_index_table> {
40801 using parent = SgAsmJvmExceptions;
40802 using field_type = SgUnsigned16List;
40803 static constexpr size_t position{0};
40804 static constexpr char const * const name{"exception_index_table"};
40805 static constexpr char const * const typestr{"SgUnsigned16List"};
40806 static constexpr bool traverse{false};
40807 static constexpr auto mbr_ptr{&SgAsmJvmExceptions::p_exception_index_table};
40808 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40809 using bind = Desc<SgAsmJvmExceptions, SgUnsigned16List SgAsmJvmExceptions::*, &SgAsmJvmExceptions::p_exception_index_table>;
40810};
40812 using node = SgAsmJvmExceptions;
40813 using base = SgAsmJvmAttribute;
40814 static constexpr char const * const name{"AsmJvmExceptions"};
40815 static constexpr unsigned long variant{1045};
40816 static constexpr bool concrete{true};
40817 using subclasses_t = mp::List<>;
40819};
40820template <> struct node_from_variant_t<1045> { using type = SgAsmJvmExceptions; };
40821
40822// Class: AsmJvmNestMembers
40823template <> struct describe_field_t<SgAsmJvmNestMembers,SgUnsigned16List,&SgAsmJvmNestMembers::p_classes> {
40825 using field_type = SgUnsigned16List;
40826 static constexpr size_t position{0};
40827 static constexpr char const * const name{"classes"};
40828 static constexpr char const * const typestr{"SgUnsigned16List"};
40829 static constexpr bool traverse{false};
40830 static constexpr auto mbr_ptr{&SgAsmJvmNestMembers::p_classes};
40831 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40832 using bind = Desc<SgAsmJvmNestMembers, SgUnsigned16List SgAsmJvmNestMembers::*, &SgAsmJvmNestMembers::p_classes>;
40833};
40835 using node = SgAsmJvmNestMembers;
40836 using base = SgAsmJvmAttribute;
40837 static constexpr char const * const name{"AsmJvmNestMembers"};
40838 static constexpr unsigned long variant{1046};
40839 static constexpr bool concrete{true};
40840 using subclasses_t = mp::List<>;
40842};
40843template <> struct node_from_variant_t<1046> { using type = SgAsmJvmNestMembers; };
40844
40845// Class: AsmJvmNestHost
40846template <> struct describe_field_t<SgAsmJvmNestHost,uint16_t,&SgAsmJvmNestHost::p_host_class_index> {
40847 using parent = SgAsmJvmNestHost;
40848 using field_type = uint16_t;
40849 static constexpr size_t position{0};
40850 static constexpr char const * const name{"host_class_index"};
40851 static constexpr char const * const typestr{"uint16_t"};
40852 static constexpr bool traverse{false};
40853 static constexpr auto mbr_ptr{&SgAsmJvmNestHost::p_host_class_index};
40854 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40855 using bind = Desc<SgAsmJvmNestHost, uint16_t SgAsmJvmNestHost::*, &SgAsmJvmNestHost::p_host_class_index>;
40856};
40858 using node = SgAsmJvmNestHost;
40859 using base = SgAsmJvmAttribute;
40860 static constexpr char const * const name{"AsmJvmNestHost"};
40861 static constexpr unsigned long variant{1047};
40862 static constexpr bool concrete{true};
40863 using subclasses_t = mp::List<>;
40865};
40866template <> struct node_from_variant_t<1047> { using type = SgAsmJvmNestHost; };
40867
40868// Class: JovialLabelDeclaration
40869template <> struct describe_field_t<SgJovialLabelDeclaration,std::string,&SgJovialLabelDeclaration::p_label> {
40871 using field_type = std::string;
40872 static constexpr size_t position{0};
40873 static constexpr char const * const name{"label"};
40874 static constexpr char const * const typestr{"std::string"};
40875 static constexpr bool traverse{false};
40876 static constexpr auto mbr_ptr{&SgJovialLabelDeclaration::p_label};
40877 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40878 using bind = Desc<SgJovialLabelDeclaration, std::string SgJovialLabelDeclaration::*, &SgJovialLabelDeclaration::p_label>;
40879};
40880template <> struct describe_field_t<SgJovialLabelDeclaration,SgJovialLabelDeclaration::label_type_enum,&SgJovialLabelDeclaration::p_label_type> {
40883 static constexpr size_t position{1};
40884 static constexpr char const * const name{"label_type"};
40885 static constexpr char const * const typestr{"SgJovialLabelDeclaration::label_type_enum"};
40886 static constexpr bool traverse{false};
40887 static constexpr auto mbr_ptr{&SgJovialLabelDeclaration::p_label_type};
40888 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40889 using bind = Desc<SgJovialLabelDeclaration, SgJovialLabelDeclaration::label_type_enum SgJovialLabelDeclaration::*, &SgJovialLabelDeclaration::p_label_type>;
40890};
40894 static constexpr char const * const name{"JovialLabelDeclaration"};
40895 static constexpr unsigned long variant{1048};
40896 static constexpr bool concrete{true};
40897 using subclasses_t = mp::List<>;
40899};
40900template <> struct node_from_variant_t<1048> { using type = SgJovialLabelDeclaration; };
40901
40902// Class: AsmJvmLocalVariableEntry
40903template <> struct describe_field_t<SgAsmJvmLocalVariableEntry,uint16_t,&SgAsmJvmLocalVariableEntry::p_start_pc> {
40905 using field_type = uint16_t;
40906 static constexpr size_t position{0};
40907 static constexpr char const * const name{"start_pc"};
40908 static constexpr char const * const typestr{"uint16_t"};
40909 static constexpr bool traverse{false};
40910 static constexpr auto mbr_ptr{&SgAsmJvmLocalVariableEntry::p_start_pc};
40911 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40912 using bind = Desc<SgAsmJvmLocalVariableEntry, uint16_t SgAsmJvmLocalVariableEntry::*, &SgAsmJvmLocalVariableEntry::p_start_pc>;
40913};
40914template <> struct describe_field_t<SgAsmJvmLocalVariableEntry,uint16_t,&SgAsmJvmLocalVariableEntry::p_length> {
40916 using field_type = uint16_t;
40917 static constexpr size_t position{1};
40918 static constexpr char const * const name{"length"};
40919 static constexpr char const * const typestr{"uint16_t"};
40920 static constexpr bool traverse{false};
40921 static constexpr auto mbr_ptr{&SgAsmJvmLocalVariableEntry::p_length};
40922 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40923 using bind = Desc<SgAsmJvmLocalVariableEntry, uint16_t SgAsmJvmLocalVariableEntry::*, &SgAsmJvmLocalVariableEntry::p_length>;
40924};
40925template <> struct describe_field_t<SgAsmJvmLocalVariableEntry,uint16_t,&SgAsmJvmLocalVariableEntry::p_name_index> {
40927 using field_type = uint16_t;
40928 static constexpr size_t position{2};
40929 static constexpr char const * const name{"name_index"};
40930 static constexpr char const * const typestr{"uint16_t"};
40931 static constexpr bool traverse{false};
40932 static constexpr auto mbr_ptr{&SgAsmJvmLocalVariableEntry::p_name_index};
40933 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40934 using bind = Desc<SgAsmJvmLocalVariableEntry, uint16_t SgAsmJvmLocalVariableEntry::*, &SgAsmJvmLocalVariableEntry::p_name_index>;
40935};
40936template <> struct describe_field_t<SgAsmJvmLocalVariableEntry,uint16_t,&SgAsmJvmLocalVariableEntry::p_descriptor_index> {
40938 using field_type = uint16_t;
40939 static constexpr size_t position{3};
40940 static constexpr char const * const name{"descriptor_index"};
40941 static constexpr char const * const typestr{"uint16_t"};
40942 static constexpr bool traverse{false};
40943 static constexpr auto mbr_ptr{&SgAsmJvmLocalVariableEntry::p_descriptor_index};
40944 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40945 using bind = Desc<SgAsmJvmLocalVariableEntry, uint16_t SgAsmJvmLocalVariableEntry::*, &SgAsmJvmLocalVariableEntry::p_descriptor_index>;
40946};
40947template <> struct describe_field_t<SgAsmJvmLocalVariableEntry,uint16_t,&SgAsmJvmLocalVariableEntry::p_index> {
40949 using field_type = uint16_t;
40950 static constexpr size_t position{4};
40951 static constexpr char const * const name{"index"};
40952 static constexpr char const * const typestr{"uint16_t"};
40953 static constexpr bool traverse{false};
40954 static constexpr auto mbr_ptr{&SgAsmJvmLocalVariableEntry::p_index};
40955 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40956 using bind = Desc<SgAsmJvmLocalVariableEntry, uint16_t SgAsmJvmLocalVariableEntry::*, &SgAsmJvmLocalVariableEntry::p_index>;
40957};
40967template <> struct node_from_variant_t<1049> { using type = SgAsmJvmLocalVariableEntry; };
40968
40969// Class: AsmJvmLocalVariableTable
40970template <> struct describe_field_t<SgAsmJvmLocalVariableTable,SgAsmJvmLocalVariableEntryPtrList,&SgAsmJvmLocalVariableTable::p_local_variable_table> {
40972 using field_type = SgAsmJvmLocalVariableEntryPtrList;
40973 static constexpr size_t position{0};
40974 static constexpr char const * const name{"local_variable_table"};
40975 static constexpr char const * const typestr{"SgAsmJvmLocalVariableEntryPtrList"};
40976 static constexpr bool traverse{false};
40977 static constexpr auto mbr_ptr{&SgAsmJvmLocalVariableTable::p_local_variable_table};
40978 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
40979 using bind = Desc<SgAsmJvmLocalVariableTable, SgAsmJvmLocalVariableEntryPtrList SgAsmJvmLocalVariableTable::*, &SgAsmJvmLocalVariableTable::p_local_variable_table>;
40980};
40983 using base = SgAsmJvmAttribute;
40984 static constexpr char const * const name{"AsmJvmLocalVariableTable"};
40985 static constexpr unsigned long variant{1050};
40986 static constexpr bool concrete{true};
40987 using subclasses_t = mp::List<>;
40989};
40990template <> struct node_from_variant_t<1050> { using type = SgAsmJvmLocalVariableTable; };
40991
40992// Class: AsmJvmLocalVariableTypeEntry
40993template <> struct describe_field_t<SgAsmJvmLocalVariableTypeEntry,uint16_t,&SgAsmJvmLocalVariableTypeEntry::p_start_pc> {
40995 using field_type = uint16_t;
40996 static constexpr size_t position{0};
40997 static constexpr char const * const name{"start_pc"};
40998 static constexpr char const * const typestr{"uint16_t"};
40999 static constexpr bool traverse{false};
41000 static constexpr auto mbr_ptr{&SgAsmJvmLocalVariableTypeEntry::p_start_pc};
41001 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
41002 using bind = Desc<SgAsmJvmLocalVariableTypeEntry, uint16_t SgAsmJvmLocalVariableTypeEntry::*, &SgAsmJvmLocalVariableTypeEntry::p_start_pc>;
41003};
41004template <> struct describe_field_t<SgAsmJvmLocalVariableTypeEntry,uint16_t,&SgAsmJvmLocalVariableTypeEntry::p_length> {
41006 using field_type = uint16_t;
41007 static constexpr size_t position{1};
41008 static constexpr char const * const name{"length"};
41009 static constexpr char const * const typestr{"uint16_t"};
41010 static constexpr bool traverse{false};
41011 static constexpr auto mbr_ptr{&SgAsmJvmLocalVariableTypeEntry::p_length};
41012 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
41013 using bind = Desc<SgAsmJvmLocalVariableTypeEntry, uint16_t SgAsmJvmLocalVariableTypeEntry::*, &SgAsmJvmLocalVariableTypeEntry::p_length>;
41014};
41015template <> struct describe_field_t<SgAsmJvmLocalVariableTypeEntry,uint16_t,&SgAsmJvmLocalVariableTypeEntry::p_name_index> {
41017 using field_type = uint16_t;
41018 static constexpr size_t position{2};
41019 static constexpr char const * const name{"name_index"};
41020 static constexpr char const * const typestr{"uint16_t"};
41021 static constexpr bool traverse{false};
41022 static constexpr auto mbr_ptr{&SgAsmJvmLocalVariableTypeEntry::p_name_index};
41023 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
41024 using bind = Desc<SgAsmJvmLocalVariableTypeEntry, uint16_t SgAsmJvmLocalVariableTypeEntry::*, &SgAsmJvmLocalVariableTypeEntry::p_name_index>;
41025};
41026template <> struct describe_field_t<SgAsmJvmLocalVariableTypeEntry,uint16_t,&SgAsmJvmLocalVariableTypeEntry::p_signature_index> {
41028 using field_type = uint16_t;
41029 static constexpr size_t position{3};
41030 static constexpr char const * const name{"signature_index"};
41031 static constexpr char const * const typestr{"uint16_t"};
41032 static constexpr bool traverse{false};
41033 static constexpr auto mbr_ptr{&SgAsmJvmLocalVariableTypeEntry::p_signature_index};
41034 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
41035 using bind = Desc<SgAsmJvmLocalVariableTypeEntry, uint16_t SgAsmJvmLocalVariableTypeEntry::*, &SgAsmJvmLocalVariableTypeEntry::p_signature_index>;
41036};
41037template <> struct describe_field_t<SgAsmJvmLocalVariableTypeEntry,uint16_t,&SgAsmJvmLocalVariableTypeEntry::p_index> {
41039 using field_type = uint16_t;
41040 static constexpr size_t position{4};
41041 static constexpr char const * const name{"index"};
41042 static constexpr char const * const typestr{"uint16_t"};
41043 static constexpr bool traverse{false};
41044 static constexpr auto mbr_ptr{&SgAsmJvmLocalVariableTypeEntry::p_index};
41045 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
41046 using bind = Desc<SgAsmJvmLocalVariableTypeEntry, uint16_t SgAsmJvmLocalVariableTypeEntry::*, &SgAsmJvmLocalVariableTypeEntry::p_index>;
41047};
41057template <> struct node_from_variant_t<1051> { using type = SgAsmJvmLocalVariableTypeEntry; };
41058
41059// Class: AsmJvmLocalVariableTypeTable
41060template <> struct describe_field_t<SgAsmJvmLocalVariableTypeTable,SgAsmJvmLocalVariableTypeEntryPtrList,&SgAsmJvmLocalVariableTypeTable::p_local_variable_type_table> {
41062 using field_type = SgAsmJvmLocalVariableTypeEntryPtrList;
41063 static constexpr size_t position{0};
41064 static constexpr char const * const name{"local_variable_type_table"};
41065 static constexpr char const * const typestr{"SgAsmJvmLocalVariableTypeEntryPtrList"};
41066 static constexpr bool traverse{false};
41067 static constexpr auto mbr_ptr{&SgAsmJvmLocalVariableTypeTable::p_local_variable_type_table};
41068 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
41069 using bind = Desc<SgAsmJvmLocalVariableTypeTable, SgAsmJvmLocalVariableTypeEntryPtrList SgAsmJvmLocalVariableTypeTable::*, &SgAsmJvmLocalVariableTypeTable::p_local_variable_type_table>;
41070};
41073 using base = SgAsmJvmAttribute;
41074 static constexpr char const * const name{"AsmJvmLocalVariableTypeTable"};
41075 static constexpr unsigned long variant{1052};
41076 static constexpr bool concrete{true};
41077 using subclasses_t = mp::List<>;
41079};
41080template <> struct node_from_variant_t<1052> { using type = SgAsmJvmLocalVariableTypeTable; };
41081
41082// Class: AsmUserInstruction
41083template <> struct describe_field_t<SgAsmUserInstruction,unsigned,&SgAsmUserInstruction::p_kind> {
41085 using field_type = unsigned;
41086 static constexpr size_t position{0};
41087 static constexpr char const * const name{"kind"};
41088 static constexpr char const * const typestr{"unsigned"};
41089 static constexpr bool traverse{false};
41090 static constexpr auto mbr_ptr{&SgAsmUserInstruction::p_kind};
41091 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
41092 using bind = Desc<SgAsmUserInstruction, unsigned SgAsmUserInstruction::*, &SgAsmUserInstruction::p_kind>;
41093};
41095 using node = SgAsmUserInstruction;
41096 using base = SgAsmInstruction;
41097 static constexpr char const * const name{"AsmUserInstruction"};
41098 static constexpr unsigned long variant{1053};
41099 static constexpr bool concrete{true};
41100 using subclasses_t = mp::List<>;
41102};
41103template <> struct node_from_variant_t<1053> { using type = SgAsmUserInstruction; };
41104
41105// Class: AsmJvmMethodParameters
41106template <> struct describe_field_t<SgAsmJvmMethodParameters,SgAsmJvmMethodParametersEntryPtrList,&SgAsmJvmMethodParameters::p_parameters> {
41108 using field_type = SgAsmJvmMethodParametersEntryPtrList;
41109 static constexpr size_t position{0};
41110 static constexpr char const * const name{"parameters"};
41111 static constexpr char const * const typestr{"SgAsmJvmMethodParametersEntryPtrList"};
41112 static constexpr bool traverse{false};
41113 static constexpr auto mbr_ptr{&SgAsmJvmMethodParameters::p_parameters};
41114 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
41115 using bind = Desc<SgAsmJvmMethodParameters, SgAsmJvmMethodParametersEntryPtrList SgAsmJvmMethodParameters::*, &SgAsmJvmMethodParameters::p_parameters>;
41116};
41119 using base = SgAsmJvmAttribute;
41120 static constexpr char const * const name{"AsmJvmMethodParameters"};
41121 static constexpr unsigned long variant{1054};
41122 static constexpr bool concrete{true};
41123 using subclasses_t = mp::List<>;
41125};
41126template <> struct node_from_variant_t<1054> { using type = SgAsmJvmMethodParameters; };
41127
41128// Class: AsmJvmMethodParametersEntry
41129template <> struct describe_field_t<SgAsmJvmMethodParametersEntry,uint16_t,&SgAsmJvmMethodParametersEntry::p_name_index> {
41131 using field_type = uint16_t;
41132 static constexpr size_t position{0};
41133 static constexpr char const * const name{"name_index"};
41134 static constexpr char const * const typestr{"uint16_t"};
41135 static constexpr bool traverse{false};
41136 static constexpr auto mbr_ptr{&SgAsmJvmMethodParametersEntry::p_name_index};
41137 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
41138 using bind = Desc<SgAsmJvmMethodParametersEntry, uint16_t SgAsmJvmMethodParametersEntry::*, &SgAsmJvmMethodParametersEntry::p_name_index>;
41139};
41140template <> struct describe_field_t<SgAsmJvmMethodParametersEntry,uint16_t,&SgAsmJvmMethodParametersEntry::p_access_flags> {
41142 using field_type = uint16_t;
41143 static constexpr size_t position{1};
41144 static constexpr char const * const name{"access_flags"};
41145 static constexpr char const * const typestr{"uint16_t"};
41146 static constexpr bool traverse{false};
41147 static constexpr auto mbr_ptr{&SgAsmJvmMethodParametersEntry::p_access_flags};
41148 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
41149 using bind = Desc<SgAsmJvmMethodParametersEntry, uint16_t SgAsmJvmMethodParametersEntry::*, &SgAsmJvmMethodParametersEntry::p_access_flags>;
41150};
41153 using base = SgAsmJvmNode;
41154 static constexpr char const * const name{"AsmJvmMethodParametersEntry"};
41155 static constexpr unsigned long variant{1055};
41156 static constexpr bool concrete{true};
41157 using subclasses_t = mp::List<>;
41159};
41160template <> struct node_from_variant_t<1055> { using type = SgAsmJvmMethodParametersEntry; };
41161
41162// Class: AsmVoidType
41163template <> struct describe_node_t<SgAsmVoidType> {
41164 using node = SgAsmVoidType;
41165 using base = SgAsmType;
41166 static constexpr char const * const name{"AsmVoidType"};
41167 static constexpr unsigned long variant{1056};
41168 static constexpr bool concrete{true};
41169 using subclasses_t = mp::List<>;
41170 using fields_t = mp::List<>;
41171};
41172template <> struct node_from_variant_t<1056> { using type = SgAsmVoidType; };
41173
41174// Class: AsmPointerType
41175template <> struct describe_field_t<SgAsmPointerType,SgAsmType *,&SgAsmPointerType::p_subtype> {
41176 using parent = SgAsmPointerType;
41177 using field_type = SgAsmType *;
41178 static constexpr size_t position{0};
41179 static constexpr char const * const name{"subtype"};
41180 static constexpr char const * const typestr{"SgAsmType *"};
41181 static constexpr bool traverse{true};
41182 static constexpr auto mbr_ptr{&SgAsmPointerType::p_subtype};
41183 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
41184 using bind = Desc<SgAsmPointerType, SgAsmType * SgAsmPointerType::*, &SgAsmPointerType::p_subtype>;
41185};
41187 using node = SgAsmPointerType;
41188 using base = SgAsmScalarType;
41189 static constexpr char const * const name{"AsmPointerType"};
41190 static constexpr unsigned long variant{1057};
41191 static constexpr bool concrete{true};
41192 using subclasses_t = mp::List<>;
41194};
41195template <> struct node_from_variant_t<1057> { using type = SgAsmPointerType; };
41196
41197// Class: RangeType
41198template <> struct describe_field_t<SgRangeType,SgType*,&SgRangeType::p_base_type> {
41199 using parent = SgRangeType;
41200 using field_type = SgType*;
41201 static constexpr size_t position{0};
41202 static constexpr char const * const name{"base_type"};
41203 static constexpr char const * const typestr{"SgType*"};
41204 static constexpr bool traverse{false};
41205 static constexpr auto mbr_ptr{&SgRangeType::p_base_type};
41206 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
41207 using bind = Desc<SgRangeType, SgType* SgRangeType::*, &SgRangeType::p_base_type>;
41208};
41209template <> struct describe_node_t<SgRangeType> {
41210 using node = SgRangeType;
41211 using base = SgType;
41212 static constexpr char const * const name{"RangeType"};
41213 static constexpr unsigned long variant{1059};
41214 static constexpr bool concrete{true};
41215 using subclasses_t = mp::List<>;
41217};
41218template <> struct node_from_variant_t<1059> { using type = SgRangeType; };
41219
41220// Class: AsmCilExceptionData
41221template <> struct describe_field_t<SgAsmCilExceptionData,std::uint32_t,&SgAsmCilExceptionData::p_flags> {
41223 using field_type = std::uint32_t;
41224 static constexpr size_t position{0};
41225 static constexpr char const * const name{"flags"};
41226 static constexpr char const * const typestr{"std::uint32_t"};
41227 static constexpr bool traverse{false};
41228 static constexpr auto mbr_ptr{&SgAsmCilExceptionData::p_flags};
41229 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
41230 using bind = Desc<SgAsmCilExceptionData, std::uint32_t SgAsmCilExceptionData::*, &SgAsmCilExceptionData::p_flags>;
41231};
41232template <> struct describe_field_t<SgAsmCilExceptionData,std::uint32_t,&SgAsmCilExceptionData::p_tryOffset> {
41234 using field_type = std::uint32_t;
41235 static constexpr size_t position{1};
41236 static constexpr char const * const name{"tryOffset"};
41237 static constexpr char const * const typestr{"std::uint32_t"};
41238 static constexpr bool traverse{false};
41239 static constexpr auto mbr_ptr{&SgAsmCilExceptionData::p_tryOffset};
41240 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
41241 using bind = Desc<SgAsmCilExceptionData, std::uint32_t SgAsmCilExceptionData::*, &SgAsmCilExceptionData::p_tryOffset>;
41242};
41243template <> struct describe_field_t<SgAsmCilExceptionData,std::uint32_t,&SgAsmCilExceptionData::p_tryLength> {
41245 using field_type = std::uint32_t;
41246 static constexpr size_t position{2};
41247 static constexpr char const * const name{"tryLength"};
41248 static constexpr char const * const typestr{"std::uint32_t"};
41249 static constexpr bool traverse{false};
41250 static constexpr auto mbr_ptr{&SgAsmCilExceptionData::p_tryLength};
41251 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
41252 using bind = Desc<SgAsmCilExceptionData, std::uint32_t SgAsmCilExceptionData::*, &SgAsmCilExceptionData::p_tryLength>;
41253};
41254template <> struct describe_field_t<SgAsmCilExceptionData,std::uint32_t,&SgAsmCilExceptionData::p_handlerOffset> {
41256 using field_type = std::uint32_t;
41257 static constexpr size_t position{3};
41258 static constexpr char const * const name{"handlerOffset"};
41259 static constexpr char const * const typestr{"std::uint32_t"};
41260 static constexpr bool traverse{false};
41261 static constexpr auto mbr_ptr{&SgAsmCilExceptionData::p_handlerOffset};
41262 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
41263 using bind = Desc<SgAsmCilExceptionData, std::uint32_t SgAsmCilExceptionData::*, &SgAsmCilExceptionData::p_handlerOffset>;
41264};
41265template <> struct describe_field_t<SgAsmCilExceptionData,std::uint32_t,&SgAsmCilExceptionData::p_handlerLength> {
41267 using field_type = std::uint32_t;
41268 static constexpr size_t position{4};
41269 static constexpr char const * const name{"handlerLength"};
41270 static constexpr char const * const typestr{"std::uint32_t"};
41271 static constexpr bool traverse{false};
41272 static constexpr auto mbr_ptr{&SgAsmCilExceptionData::p_handlerLength};
41273 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
41274 using bind = Desc<SgAsmCilExceptionData, std::uint32_t SgAsmCilExceptionData::*, &SgAsmCilExceptionData::p_handlerLength>;
41275};
41276template <> struct describe_field_t<SgAsmCilExceptionData,std::uint32_t,&SgAsmCilExceptionData::p_classTokenOrFilterOffset> {
41278 using field_type = std::uint32_t;
41279 static constexpr size_t position{5};
41280 static constexpr char const * const name{"classTokenOrFilterOffset"};
41281 static constexpr char const * const typestr{"std::uint32_t"};
41282 static constexpr bool traverse{false};
41283 static constexpr auto mbr_ptr{&SgAsmCilExceptionData::p_classTokenOrFilterOffset};
41284 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
41285 using bind = Desc<SgAsmCilExceptionData, std::uint32_t SgAsmCilExceptionData::*, &SgAsmCilExceptionData::p_classTokenOrFilterOffset>;
41286};
41296template <> struct node_from_variant_t<1060> { using type = SgAsmCilExceptionData; };
41297
41298// Class: AsmCilMethodData
41299template <> struct describe_field_t<SgAsmCilMethodData,uint64_t,&SgAsmCilMethodData::p_kind> {
41300 using parent = SgAsmCilMethodData;
41301 using field_type = uint64_t;
41302 static constexpr size_t position{0};
41303 static constexpr char const * const name{"kind"};
41304 static constexpr char const * const typestr{"uint64_t"};
41305 static constexpr bool traverse{false};
41306 static constexpr auto mbr_ptr{&SgAsmCilMethodData::p_kind};
41307 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
41308 using bind = Desc<SgAsmCilMethodData, uint64_t SgAsmCilMethodData::*, &SgAsmCilMethodData::p_kind>;
41309};
41310template <> struct describe_field_t<SgAsmCilMethodData,std::uint32_t,&SgAsmCilMethodData::p_dataSize> {
41311 using parent = SgAsmCilMethodData;
41312 using field_type = std::uint32_t;
41313 static constexpr size_t position{1};
41314 static constexpr char const * const name{"dataSize"};
41315 static constexpr char const * const typestr{"std::uint32_t"};
41316 static constexpr bool traverse{false};
41317 static constexpr auto mbr_ptr{&SgAsmCilMethodData::p_dataSize};
41318 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
41319 using bind = Desc<SgAsmCilMethodData, std::uint32_t SgAsmCilMethodData::*, &SgAsmCilMethodData::p_dataSize>;
41320};
41321template <> struct describe_field_t<SgAsmCilMethodData,std::vector<SgAsmCilExceptionData*>,&SgAsmCilMethodData::p_clauses> {
41322 using parent = SgAsmCilMethodData;
41323 using field_type = std::vector<SgAsmCilExceptionData*>;
41324 static constexpr size_t position{2};
41325 static constexpr char const * const name{"clauses"};
41326 static constexpr char const * const typestr{"std::vector<SgAsmCilExceptionData*>"};
41327 static constexpr bool traverse{false};
41328 static constexpr auto mbr_ptr{&SgAsmCilMethodData::p_clauses};
41329 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
41330 using bind = Desc<SgAsmCilMethodData, std::vector<SgAsmCilExceptionData*> SgAsmCilMethodData::*, &SgAsmCilMethodData::p_clauses>;
41331};
41333 using node = SgAsmCilMethodData;
41334 using base = SgAsmCilNode;
41335 static constexpr char const * const name{"AsmCilMethodData"};
41336 static constexpr unsigned long variant{1061};
41337 static constexpr bool concrete{true};
41338 using subclasses_t = mp::List<>;
41340};
41341template <> struct node_from_variant_t<1061> { using type = SgAsmCilMethodData; };
41342
41343// Class: TemplateVariableInstantiation
41344template <> struct describe_field_t<SgTemplateVariableInstantiation,SgName,&SgTemplateVariableInstantiation::p_templateName> {
41346 using field_type = SgName;
41347 static constexpr size_t position{0};
41348 static constexpr char const * const name{"templateName"};
41349 static constexpr char const * const typestr{"SgName"};
41350 static constexpr bool traverse{false};
41351 static constexpr auto mbr_ptr{&SgTemplateVariableInstantiation::p_templateName};
41352 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
41353 using bind = Desc<SgTemplateVariableInstantiation, SgName SgTemplateVariableInstantiation::*, &SgTemplateVariableInstantiation::p_templateName>;
41354};
41355template <> struct describe_field_t<SgTemplateVariableInstantiation,SgName,&SgTemplateVariableInstantiation::p_templateHeader> {
41357 using field_type = SgName;
41358 static constexpr size_t position{1};
41359 static constexpr char const * const name{"templateHeader"};
41360 static constexpr char const * const typestr{"SgName"};
41361 static constexpr bool traverse{false};
41362 static constexpr auto mbr_ptr{&SgTemplateVariableInstantiation::p_templateHeader};
41363 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
41364 using bind = Desc<SgTemplateVariableInstantiation, SgName SgTemplateVariableInstantiation::*, &SgTemplateVariableInstantiation::p_templateHeader>;
41365};
41366template <> struct describe_field_t<SgTemplateVariableInstantiation,SgTemplateVariableDeclaration*,&SgTemplateVariableInstantiation::p_templateDeclaration> {
41369 static constexpr size_t position{2};
41370 static constexpr char const * const name{"templateDeclaration"};
41371 static constexpr char const * const typestr{"SgTemplateVariableDeclaration*"};
41372 static constexpr bool traverse{false};
41373 static constexpr auto mbr_ptr{&SgTemplateVariableInstantiation::p_templateDeclaration};
41374 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
41375 using bind = Desc<SgTemplateVariableInstantiation, SgTemplateVariableDeclaration* SgTemplateVariableInstantiation::*, &SgTemplateVariableInstantiation::p_templateDeclaration>;
41376};
41377template <> struct describe_field_t<SgTemplateVariableInstantiation,SgTemplateArgumentPtrList,&SgTemplateVariableInstantiation::p_templateArguments> {
41379 using field_type = SgTemplateArgumentPtrList;
41380 static constexpr size_t position{3};
41381 static constexpr char const * const name{"templateArguments"};
41382 static constexpr char const * const typestr{"SgTemplateArgumentPtrList"};
41383 static constexpr bool traverse{false};
41384 static constexpr auto mbr_ptr{&SgTemplateVariableInstantiation::p_templateArguments};
41385 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
41386 using bind = Desc<SgTemplateVariableInstantiation, SgTemplateArgumentPtrList SgTemplateVariableInstantiation::*, &SgTemplateVariableInstantiation::p_templateArguments>;
41387};
41397template <> struct node_from_variant_t<1062> { using type = SgTemplateVariableInstantiation; };
41398
41399// Class: ReferenceExp
41400template <> struct describe_node_t<SgReferenceExp> {
41401 using node = SgReferenceExp;
41402 using base = SgExpression;
41403 static constexpr char const * const name{"ReferenceExp"};
41404 static constexpr unsigned long variant{1063};
41405 static constexpr bool concrete{false};
41407 using fields_t = mp::List<>;
41408};
41409template <> struct node_from_variant_t<1063> { using type = SgReferenceExp; };
41410
41411// Class: TypeRefExp
41412template <> struct describe_field_t<SgTypeRefExp,SgNamedType * ,&SgTypeRefExp::p_named_type> {
41413 using parent = SgTypeRefExp;
41414 using field_type = SgNamedType * ;
41415 static constexpr size_t position{0};
41416 static constexpr char const * const name{"named_type"};
41417 static constexpr char const * const typestr{"SgNamedType * "};
41418 static constexpr bool traverse{false};
41419 static constexpr auto mbr_ptr{&SgTypeRefExp::p_named_type};
41420 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
41421 using bind = Desc<SgTypeRefExp, SgNamedType * SgTypeRefExp::*, &SgTypeRefExp::p_named_type>;
41422};
41423template <> struct describe_node_t<SgTypeRefExp> {
41424 using node = SgTypeRefExp;
41425 using base = SgReferenceExp;
41426 static constexpr char const * const name{"TypeRefExp"};
41427 static constexpr unsigned long variant{1064};
41428 static constexpr bool concrete{true};
41429 using subclasses_t = mp::List<>;
41431};
41432template <> struct node_from_variant_t<1064> { using type = SgTypeRefExp; };
41433
41434// Class: ScopedRefExp
41435template <> struct describe_field_t<SgScopedRefExp,SgReferenceExp * ,&SgScopedRefExp::p_lhs> {
41436 using parent = SgScopedRefExp;
41437 using field_type = SgReferenceExp * ;
41438 static constexpr size_t position{0};
41439 static constexpr char const * const name{"lhs"};
41440 static constexpr char const * const typestr{"SgReferenceExp * "};
41441 static constexpr bool traverse{true};
41442 static constexpr auto mbr_ptr{&SgScopedRefExp::p_lhs};
41443 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
41444 using bind = Desc<SgScopedRefExp, SgReferenceExp * SgScopedRefExp::*, &SgScopedRefExp::p_lhs>;
41445};
41446template <> struct describe_field_t<SgScopedRefExp,SgReferenceExp * ,&SgScopedRefExp::p_rhs> {
41447 using parent = SgScopedRefExp;
41448 using field_type = SgReferenceExp * ;
41449 static constexpr size_t position{1};
41450 static constexpr char const * const name{"rhs"};
41451 static constexpr char const * const typestr{"SgReferenceExp * "};
41452 static constexpr bool traverse{true};
41453 static constexpr auto mbr_ptr{&SgScopedRefExp::p_rhs};
41454 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
41455 using bind = Desc<SgScopedRefExp, SgReferenceExp * SgScopedRefExp::*, &SgScopedRefExp::p_rhs>;
41456};
41457template <> struct describe_node_t<SgScopedRefExp> {
41458 using node = SgScopedRefExp;
41459 using base = SgReferenceExp;
41460 static constexpr char const * const name{"ScopedRefExp"};
41461 static constexpr unsigned long variant{1065};
41462 static constexpr bool concrete{true};
41463 using subclasses_t = mp::List<>;
41465};
41466template <> struct node_from_variant_t<1065> { using type = SgScopedRefExp; };
41467
41468// Class: ScopedType
41469template <> struct describe_node_t<SgScopedType> {
41470 using node = SgScopedType;
41471 using base = SgNamedType;
41472 static constexpr char const * const name{"ScopedType"};
41473 static constexpr unsigned long variant{1066};
41474 static constexpr bool concrete{true};
41475 using subclasses_t = mp::List<>;
41476 using fields_t = mp::List<>;
41477};
41478template <> struct node_from_variant_t<1066> { using type = SgScopedType; };
41479
41480// Class: TypeSymbol
41481template <> struct describe_node_t<SgTypeSymbol> {
41482 using node = SgTypeSymbol;
41483 using base = SgSymbol;
41484 static constexpr char const * const name{"TypeSymbol"};
41485 static constexpr unsigned long variant{1067};
41486 static constexpr bool concrete{true};
41488 using fields_t = mp::List<>;
41489};
41490template <> struct node_from_variant_t<1067> { using type = SgTypeSymbol; };
41491
41492// Class: AsmJvmSynthetic
41494 using node = SgAsmJvmSynthetic;
41495 using base = SgAsmJvmAttribute;
41496 static constexpr char const * const name{"AsmJvmSynthetic"};
41497 static constexpr unsigned long variant{1068};
41498 static constexpr bool concrete{true};
41499 using subclasses_t = mp::List<>;
41500 using fields_t = mp::List<>;
41501};
41502template <> struct node_from_variant_t<1068> { using type = SgAsmJvmSynthetic; };
41503
41504// Class: AsmJvmDeprecated
41506 using node = SgAsmJvmDeprecated;
41507 using base = SgAsmJvmAttribute;
41508 static constexpr char const * const name{"AsmJvmDeprecated"};
41509 static constexpr unsigned long variant{1069};
41510 static constexpr bool concrete{true};
41511 using subclasses_t = mp::List<>;
41512 using fields_t = mp::List<>;
41513};
41514template <> struct node_from_variant_t<1069> { using type = SgAsmJvmDeprecated; };
41515
41516// Class: SignedCharVal
41517template <> struct describe_field_t<SgSignedCharVal,signed char,&SgSignedCharVal::p_value> {
41518 using parent = SgSignedCharVal;
41519 using field_type = signed char;
41520 static constexpr size_t position{0};
41521 static constexpr char const * const name{"value"};
41522 static constexpr char const * const typestr{"signed char"};
41523 static constexpr bool traverse{false};
41524 static constexpr auto mbr_ptr{&SgSignedCharVal::p_value};
41525 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
41526 using bind = Desc<SgSignedCharVal, signed char SgSignedCharVal::*, &SgSignedCharVal::p_value>;
41527};
41528template <> struct describe_field_t<SgSignedCharVal,std::string,&SgSignedCharVal::p_valueString> {
41529 using parent = SgSignedCharVal;
41530 using field_type = std::string;
41531 static constexpr size_t position{1};
41532 static constexpr char const * const name{"valueString"};
41533 static constexpr char const * const typestr{"std::string"};
41534 static constexpr bool traverse{false};
41535 static constexpr auto mbr_ptr{&SgSignedCharVal::p_valueString};
41536 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
41537 using bind = Desc<SgSignedCharVal, std::string SgSignedCharVal::*, &SgSignedCharVal::p_valueString>;
41538};
41540 using node = SgSignedCharVal;
41541 using base = SgValueExp;
41542 static constexpr char const * const name{"SignedCharVal"};
41543 static constexpr unsigned long variant{1070};
41544 static constexpr bool concrete{true};
41545 using subclasses_t = mp::List<>;
41547};
41548template <> struct node_from_variant_t<1070> { using type = SgSignedCharVal; };
41549
41550} } }
41551#endif /* Rose_Traits_generated_h */
Stores named attributes in Sage IR nodes.
Describes (part of) a physical CPU register.
Optionally bound relative virtual address.
access_modifier_enum
Access Modifiers (only one value can be specified)
SgExprListExp * p_initializers
This points to a SgExprListExp (list of expressions).
Operand referencing a Co-processor.
String associated with a binary file.
Expression that adds two operands.
Expression that performs an arithmetic, sign-bit preserving right shift.
Expression that concatenates two values to form a wider value.
Expression that divides the first operand by the second.
Base class for binary expressions.
Expression that performs a logical left shift operation.
Expression that performs a logical, sign-bit non-preserving right shift.
Expression that returns the remainder when dividing the first operand by the second.
Expression that performs a logical left shift operation filling low-order bits with one.
Expression that multiplies two operands.
Expression that represents an update to a storage location.
Expression that represents an update to a storage location.
Expression that performs a right rotate.
Expression that subtracts the second operand from the first.
Instruction basic block.
Byte order specification.
CIL AssemblyOS tables.
CIL AssemblyOS node (II.22.3).
CIL AssemblyProcessor tables.
CIL AssemblyProcessor node (II.22.4).
CIL AssemblyRefOS tables.
CIL AssemblyRefOS node (II.22.6).
CIL AssemblyRefProcessor tables.
CIL AssemblyRefProcessor node (II.22.7).
CIL AssemblyRef tables.
CIL AssemblyRef node (II.22.5).
CIL Assembly tables.
CIL Assembly node (II.22.2).
CIL ClassLayout tables.
CIL ClassLayout node (II.22.8).
CIL Constant tables.
CIL Constant node (II.22.9).
CIL CustomAttribute tables.
CIL CustomAttribute node (II.22.10).
Base class for CIL branch of binary analysis IR nodes.
CIL DeclSecurity tables.
CIL DeclSecurity node (II.22.11).
CIL EventMap tables.
CIL EventMap node (II.22.12).
CIL Event node (II.22.13).
Property class representing CIL Exception clauses (II.25.4.6).
CIL ExportedType tables.
CIL ExportedType node (II.22.14).
CIL FieldLayout tables.
CIL FieldLayout node (II.22.16).
CIL FieldMarshal tables.
CIL FieldMarshal node (II.22.17).
CIL FieldRVA tables.
CIL FieldRVA node (II.22.18).
CIL Field node (II.22.15).
CIL File node (II.22.19).
CIL GenericParamConstraint tables.
CIL GenericParamConstraint node (II.22.21).
CIL GenericParam tables.
CIL GenericParam node (II.22.20).
CIL ImplMap tables.
CIL ImplMap node (II.22.22).
CIL InterfaceImpl tables.
CIL InterfaceImpl node (II.22.23).
CIL ManifestResource tables.
CIL ManifestResource node (II.22.24).
CIL MemberRef tables.
CIL MemberRef node (II.22.25).
CIL SgAsmCilMetadataHeap node.
CIL SgAsmCilMetadataRoot.
Base class for CIL branch of binary analysis IR nodes.
Property class representing CIL Extra Sections (II.25.4.5).
CIL MethodDef tables.
CIL MethodDef node (II.22.26).
CIL MethodImpl tables.
CIL MethodImpl node (II.22.27).
CIL MethodSemantics tables.
CIL MethodSemantics node (II.22.28).
CIL MethodSpec tables.
CIL MethodSpec node (II.22.29).
CIL ModuleRef tables.
CIL ModuleRef node (II.22.31).
CIL Module node (II.22.30).
CIL NestedClass tables.
CIL NestedClass node (II.22.32).
Base class for CIL branch of binary analysis IR nodes.
CIL Param node (II.22.33).
CIL PropertyMap tables.
CIL PropertyMap node (II.22.35).
CIL Property tables.
CIL Property node (II.22.34).
CIL StandAloneSig tables.
CIL StandAloneSig node (II.22.36).
CIL TypeDef tables.
CIL TypeDef node (II.22.37).
CIL TypeRef tables.
CIL TypeRef node (II.22.38).
CIL TypeSpec tables.
CIL TypeSpec node (II.22.39).
Base class for CIL branch of binary analysis IR nodes.
Base class for CIL branch of binary analysis IR nodes.
CIL Managed Code section.
COFF symbol string table.
List of COFF symbols.
Base class for constants.
Represents the file header for DOS executables.
Expression representing a machine register.
List of dynamic linking section entries.
One entry from the dynamic linking table.
ELF section containing dynamic linking information.
List of ELF EH frame CI entries.
ELF error handling frame entry, common information entry.
List of ELF error handling frame descriptor entries.
ELF error handling frame entry frame description entry.
Represents an ELF EH frame section.
Represents the file header of an ELF binary container.
Node to hold list of ELF note entries.
One entry of an ELF notes table.
List of ELF relocation entries.
One entry of an ELF relocation table.
RelocType
Relocation Type.
Represents an ELF relocation section.
Represents one entry in an ELF section table.
SectionType
Section types (host order).
Represents an ELF section table.
Base class for ELF file sections.
Represents one entry of a segment table.
SegmentType
Segment types (host order).
Represents an ELF segment table.
ELF string table section.
ELF string table.
ELF file section containing symbols.
Represents a single ELF symbol.
List of symbol version aux entries.
Auxiliary data for an ELF Symbol Version.
List of entries for the ELF symbol version definition table.
One entry from an ELF symbol version definition table.
The GNU symbol version definitions.
List of entries from a symbol version table.
Entry in an ELF symbol version table.
Hods a list of symbol version aux entries.
Auxiliary info for needed symbol version.
List of symbol version needed entries.
One entry of the ELF symbol version needed table.
GNU symbol version requirements table.
The ELF symbol version table.
Base class for many binary analysis nodes.
ExecPurpose
General purpose of a binary executable file.
ExecABI
Application binary interface.
InsSetArchitecture
Instruction sets organized by families.
List of expression nodes.
Base class for expressions.
Floating point types.
Represents a synthesized function.
function_kind_enum
Constants for the "function_kind" property.
MayReturn
Whether a function returns.
List of pointers to other nodes.
Base class for dynamically linked library information.
List of AST file node pointers.
Base class for binary files.
Basic information about an executable container.
List of generic file headers.
Base class for container file headers.
List of pointers to file sections.
Contiguous region of a file.
SectionPurpose
Reason for section's existence.
Base class for strings related to binary specimens.
Base class for string tables.
Node to hold a list of symbol node pointers.
SymbolBinding
Symbol binding.
SymbolDefState
Symbol definition state.
Registers accessed indirectly.
List of SgAsmInstruction nodes.
Base class for machine instructions.
Base class for integer values.
Represents an interpretation of a binary container.
Represents a JVM attribute_info table/array.
Base class for a JVM attribute.
The BootstrapMethods attribute is a variable-length attribute in the attributes table of a ClassFile ...
Represents an entry in a JVM constant pool.
Represents an JVM constant pool.
JVM ConstantValue attribute.
JVM Deprecated attribute.
JVM EnclosingMethod attribute.
Represents a JVM exception_info table/array.
JVM Exceptions attribute.
Represents a JVM field_info table/array.
Represents the file header of an JVM binary container.
A JVM InnerClasses attribute array entry.
Represents a JVM InnerClasses attribute.
Represents one JVS machine instruction.
JVM LineNumberTable attribute.
JVM LocalVariableEntry.
JVM LocalVariableTable attribute.
JVM LocalVariableTypeEntry.
JVM LocalVariableTypeTable attribute.
JVM MethodParametersEntry.
JVM MethodParameters attribute.
Represents a JVM method_info table/array.
JVM ModuleMainClass attribute.
JVM NestHost attribute.
JVM NestMembers attribute.
Base class for JVM branch of binary analysis IR nodes.
JVM Signature attribute.
JVM SourceFile attribute.
Represents a frame in a stack map table.
The StackMapTable attribute is a variable-length attribute in the attributes table of a Code attribut...
Represents an entry in a stack map table.
JVM Synthetic attribute.
Reference to memory locations.
Represents one MIPS machine instruction.
Base class for all binary analysis IR nodes.
asm_operand_constraint_enum
ASM operand constraints (multiple values can be specified)
asm_operand_modifier_enum
ASM Operand modifiers (multiple values can be specified)
List of operands for an instruction.
List of pointers to other AST nodes.
Export file section.
Windows PE file header.
A list of PE Import Directories.
One import directory per library.
A list of imported items.
A single imported object.
Portable Executable Import Section.
List of SgAsmPERVASizePair AST nodes.
Base class for PE sections.
Represents one PowerPC machine instruction.
An ordered list of registers.
Base class for references to a machine register.
Static representation of instruction semantics.
RiscOperator
One enum per RISC operator.
Base class for scalar types.
Base class for references to a machine register.
Base class for statement-like subclasses.
Represents static data in an executable.
This class represents the concept of a C Assembler statement.
SgAsmStmt::AsmRegisterNameList p_clobberRegisterList
This is the clobber list (list of registers where side-effects happen).
SgExpressionPtrList p_operands
List of expressions.
Strings stored in an ELF or PE container.
Strings stored in an ELF or PE container.
Declaration-like nodes that encapsulate multiple instructions.
Base class for synthesized declarations.
Base class for binary types.
Base class for unary expressions.
Expression represting negation.
Expression representing a (no-op) unary plus operation.
Expression representing sign extending.
Expression representing truncation.
Expression representing unsigned extending.
Instructions defined at runtime.
Base class for values.
Base class for vector types.
A type that doesn't represent any data.
Represents one Intel x86 machine instruction.
This class represents the rhs of a variable declaration which includes an optional assignment (e....
SgExpression * p_operand_i
This points to the internal SgExpression (right-hand-side expression).
SgType * p_expression_type
This points to the SgType of the rhs expression.
attribute_spec_enum
Fortran specific classification of attribute statements (each corresponds to a declaration attribute)...
baseclass_modifier_enum
Baseclass Modifiers (only one value can be specified)
This class represents the concept of a block (not a basic block from control flow analysis).
SgStatementPtrList p_statements
This pointer an STL list of pointers to SgStatement objects.
This class represents the notion of a binary operator. It is derived from a SgExpression because oper...
SgType * p_expression_type
This SgType is the type of the operator (function type).
SgExpression * p_rhs_operand_i
This is the operand associated with the rhs of the binary operator.
SgExpression * p_lhs_operand_i
This is the operand associated with the lhs of the binary operator.
This class represents a boolean value (expression value).
int p_value
This boolean variable marks the current expression as a left hand side value (lvalue).
This class represents the notion of a break statement (typically used in a switch statment).
This class represents the concept of a generic call expression.
SgExprListExp * p_args
This is a pointer to a SgExprListExp (list of function arguments)
SgType * p_expression_type
This is the type of the return value of the function.
SgExpression * p_function
This pointer points to the expression being assembled with argments for be a function call.
This class represents the concept of a C and C++ case option (used within a switch statement).
SgStatement * p_body
This pointer points to a SgBasicBlock object.
SgExpression * p_key_range_end
This pointer points to the last constant in the range when a gnu range case label is used.
This class represents a cast of one type to another.
cast_type_enum
Classification of Casts.
This class represents the concept of a catch within a try-catch construct used in C++ exception handl...
SgTryStmt * p_trystmt
This pointer to a SgTryStmt (a declaration) that is associated with this catch option.
SgStatement * p_body
This pointer to a SgBasicBlock used to hold the statements to be executed when the exception is caugh...
SgVariableDeclaration * p_condition
This pointer to a SgVariableDeclaration.
This class represents the concept of a C++ sequence of catch statements.
SgStatementPtrList p_catch_statement_seq
This is an STL list of pointers to SgStatement objects.
This class represents the concept of a class declaration statement. It includes the concept of an ins...
SgName p_name
This is the name of the class or instantiated class template.
SgClassDefinition * p_definition
This is the class definition (alway a valid pointer, except for explicitly marked forward declaration...
bool p_from_template
This records if the class declaration is associated with a template.
SgClassType * p_type
This is the type used in the declaration (SgClassType).
SgClassDeclaration::class_types p_class_type
Enum value classifying this as a class,struct,or union.
This class represents the concept of a class definition in C++.
SgDeclarationStatementPtrList p_members
This the list of member declarations in the class.
SgBaseClassPtrList p_inheritances
This the list of base classes specificed in the class definition.
This class represents the concept of a C++ expression built from a class name.
SgClassSymbol * p_symbol
This pointer points to a SgClassSymbol.
This class represents the concept of a class name within the compiler.
This class represents the concept of a C style extern "C" declaration. But such information (linkage)...
This class represents the concept of a C trinary conditional expression (e.g. "test ?...
SgExpression * p_conditional_exp
This pointer points to a SgExpression object.
SgExpression * p_false_exp
This pointer points to a SgExpression object.
SgExpression * p_true_exp
This pointer points to a SgExpression object.
SgType * p_expression_type
This pointer points to a SgType object.
cv_modifier_enum
Const Volatile Modifier.
This class represents the call of a class constructor to initialize a variable. For example "Foo foo;...
SgType * p_expression_type
This points to the associated type for this constructor.
bool p_need_parenthesis_after_name
This bool value controls the output of "()" after the class name.
bool p_associated_class_unknown
This bool value indicates when p_declaration should be a valid pointer.
bool p_need_qualifier
This bool value controls the output of the class names qualifier.
SgMemberFunctionDeclaration * p_declaration
This points to the associated member function declaration (a constructor).
SgExprListExp * p_args
This points to the argument list of the associated constructor call.
bool p_need_name
This bool value controls the output of the class name.
This class represents the concept of a C or C++ continue statement.
This class represents the concept of a contructor initializer list (used in constructor (member funct...
SgInitializedNamePtrList p_ctors
This is an STL list of pointers to SgInitializedName objects.
data_statement_value_enum
Support for Fortran data statement.
This class represents modifiers for SgDeclaration (declaration statements).
SgStorageModifier p_storageModifier
Modified for storage information.
SgAccessModifier p_accessModifier
Modifier for access information (only set for declarations in class and struct definitions)
SgBitVector p_modifierVector
Bit vector permitting specification of flags for friend, typedef, export, throw.
SgTypeModifier p_typeModifier
Modifier for type information.
gnu_declaration_visability_enum
GNU attribute for visability (only one value can be specified)
This class represents the concept of a declaration statement.
bool p_nameOnly
I think this is somewhat redundant with the purpose of specifying a forward declaration....
gnu_extension_visability_attribute_enum
GNU extension for visibility modifier (only one value can be specified)
SgDeclarationStatement * p_firstNondefiningDeclaration
This pointer is valid if there is a non-defining declaration, and stores the first non-defining decla...
std::string p_linkage
This string stores the value "C", "C++", or "fortran" to define the external linkage for generating l...
template_specialization_enum
Template Specialization Support.
SgDeclarationModifier p_declarationModifier
This is the mechanism to handle declaration modifiers.
SgDeclarationStatement * p_definingDeclaration
This pointer is valid only if a defining declaration exists, and stores the defining declaration wher...
bool p_externBrace
This marks that the declaration appeared with "extern".
unsigned int p_decl_attributes
This is old and used to be used to hold modifiers.
bool p_forward
This marks a declaration as being an explicit forward declaration.
bool p_skipElaborateType
This marks "type elaboration" which is the use of the keyword "class" before variables of type class.
This class represents the concept of a C or C++ default case within a switch statement.
SgStatement * p_body
This pointer points to SgBasicBlock holding the statements executed for the default case of a switch ...
This class represents the concept of a C++ call to the delete operator.
short p_need_global_specifier
This delete operator needs to be output with "::".
SgExpression * p_variable
This pointer points to the variable being deleted.
short p_is_array
This bool value is true only if the delete operator is called on an array (array delete).
This class represents a directory within a projects file structure of files and directories.
This class represents the concept of a do-while statement.
SgStatement * p_condition
This pointer a SgStatement, the conditional expression in the loop construct.
SgStatement * p_body
This pointer a SgBasicBlock, and holds the statements in the body of the loop.
This class represents the notion of an value (expression value).
double p_value
This value holds the double represented in the source code.
elaborated_type_modifier_enum
Elaborated Type Modifiers (only one value can be specified)
This class represents the concept of an enum declaration.
SgName p_name
Name of enum type (empty if not named).
SgEnumType * p_type
SgEnumType generated by this enum declaration.
SgScopeStatement * p_scope
Scope of enum declaration.
SgInitializedNamePtrList p_enumerators
STL list of pointers to SgInitializedName object (used for enum variables).
bool p_embedded
Boolean value true if embedded in a typedef declaration (might not be used).
This class represents the concept of the dynamic execution of a string, file, or code object....
SgExpression * p_globals
The global execution environment.
SgExpression * p_executable
The object to be executed.
SgExpression * p_locals
The local execution environment.
This class represents the concept of a C and C++ expression list.
This class represents the concept of a C or C++ statement which contains a expression.
This class represents the notion of an expression. Expressions are derived from SgLocatedNodes,...
bool p_lvalue
This boolean variable marks the current expression as a left hand side value (lvalue).
bool p_need_paren
This boolean value marks the current expression as requiring parenthises.
This class represents a source file for a project (which may contian many source files and or directo...
ROSEAttributesListContainerPtr p_preprocessorDirectivesAndCommentsList
This is the container of comments and preprocessor control statements that was extracted from the fil...
outputFormatOption_enum
Enum type used to specify output of Fortran as fixed for free format.
bool p_no_implicit_inline_templates
This is a reference to the GNU g++ command line option (same name).
bool p_no_implicit_templates
This is a reference to the GNU g++ command line option (same name).
SgStringList p_originalCommandLineArgumentList
Copy of original argc and argv command line passed to ROSE translator (converted to STL list of strin...
languageOption_enum
Enum type used to specify output language (option used for testing unparsers).
This class represents the notion of an value (expression value).
float p_value
This value holds the float represented in the source code.
forall_statement_kind_enum
This class represents forall statements and the Fortran do concurrent construct.
This class represents the variable declaration or variable initialization withn a for loop.
SgStatementPtrList p_init_stmt
This pointer points to list of initializers in a SgForStatement.
This class represents the concept of a for loop.
SgForInitStatement * p_for_init_stmt
This pointer a SgForInitStatement (a list of pointers to statements (SgStatement objects) ).
SgStatement * p_loop_body
This pointer a SgBasicBlock, and holds the statements in the body of the loop.
SgStatement * p_else_body
Holds the statements in the else body of the loop. Currently, only Python supports for loops with els...
This class represents the concept of a C++ function call (which is an expression).
This class represents the concept of a function declaration statement.
SgFunctionDefinition * p_definition
This variable stores the SgFunctionDefinition.
SgName p_name
This variable stores the string representing the function name.
SgFunctionType * p_type
This variable stores the SgFunctionType.
SgExprListExp * p_decoratorList
This variable stores a list of decorators.
bool p_oldStyleDefinition
This boolean variable records if the function uses the old style definition.
SgSpecialFunctionModifier p_specialFunctionModifier
This variable stores flags representing use of constructor, destructor, etc.
SgFunctionModifier p_functionModifier
This variable stores flags representing use of inline, virtual, etc.
This class represents the concept of a scope in C++ (e.g. global scope, fuction scope,...
SgBasicBlock * p_body
This pointer is always valid and points to a SgBasicBlock holding all the statements in the function.
This class represents the concept of a declaration list.
SgInitializedNamePtrList p_args
STL list of pointers to SgInitializedName object (used for function parameter declarations).
This class represents the function being called and must be assembled in the SgFunctionCall with the ...
This class represents the concept of a name and a type. It may be renamed in the future to SgTypeSymb...
This class represents the function type table (stores all function types so that they can be shared i...
SgSymbolTable * p_function_type_table
This pointer points to SgSymbolTable used to store function type symbols only.
This class represents a type for all functions.
This class represents the concept of a namespace definition.
SgDeclarationStatementPtrList p_declarations
This is an STL list of SgDeclarationStatement objects.
This class represents the concept of a C or C++ goto statement.
SgLabelStatement * p_label
This pointer points to the SgLabelStatement where control flow will be transfered during execution.
io_statement_enum
Fortran specific classification.
This class represents the concept of an "if" construct.
SgStatement * p_conditional
This pointer a SgStatement.
SgStatement * p_false_body
This pointer a SgBasicBlock, and holds the statements in the "false" body of if statement.
SgStatement * p_true_body
This pointer a SgBasicBlock, and holds the statements in the "true" body of if statement.
image_control_statement_enum
Fortran specific classification for image control statements.
This class represents the notion of a declared variable.
SgInitializedName * p_prev_decl_item
Pointer to the initial uses of this variable previous to its redeclaration declaration.
SgStorageModifier * p_storageModifier
This is the storage modifier (static, auto, register, mutable, asm, etc.).
asm_register_name_enum
Register names (x86 specific GNU names).
SgScopeStatement * p_scope
This pointer is always valid and stores the current scope of the variable.
bool p_is_initializer
flag to determine whether the declaration has an initializer.
SgInitializedName::asm_register_name_enum p_register_name_code
Code (following GNU standard) for register name.
SgInitializer * p_initptr
Pointer to an initializer for the variable.
SgInitializedName::preinitialization_enum p_preinitialization
This data member stores an enum value.
SgType * p_typeptr
Pointer to a type object that has been associated with SgInitializedName::p_name.
SgName p_name
The variable that is declared in this declaration.
SgDeclarationStatement * p_declptr
Pointer to the declaration object where this SgInitializedName object belongs to.
preinitialization_enum
Preinitialization Enum (only one value can be specified)
This class represents the notion of an initializer for a variable declaration or expression in a func...
bool p_is_explicit_cast
This boolean variable marks the initializer ans part of an explicit or implicit cast....
This class represents the physical disequality (often called pointer disequality) operator for langua...
This class represents the physical equality (often called pointer equality) operator for languages th...
loop_statement_type_enum
This class represents the various versions of Jovial loop statements.
WordsPerEntry
Enum for words-per-entry in a Jovial table.
StructureSpecifier
Enum for Jovial structure specifiers.
This class represents the concept of a C or C++ label statement.
SgName p_label
This a SgName object which stores the name of the label.
label_type_enum
Type of label used (fortran only)
This class represents a lambda expression.
SgFunctionDeclaration * p_functionDeclaration
The implicit function referred to by this lambda.
linkage_modifier_enum
Linkage Modifiers (only one value can be specified)
This class represents a list display.
This class represents the notion of an expression or statement which has a position within the source...
AttachedPreprocessingInfoType * p_attachedPreprocessingInfoPtr
Holds comments and/or preprocessor directives located before or after the current statement of expres...
Sg_File_Info * p_endOfConstruct
This pointer is always valid and stores the source position of the end of the current construct.
Sg_File_Info * p_startOfConstruct
This pointer is always valid and stores the source position of the start of the current construct.
This class represents the notion of an value (expression value).
long double p_value
This value holds the double represented in the source code.
This class represents the concept of a member function declaration statement.
SgCtorInitializerList * p_CtorInitializerList
This is the constructor preinitialization list (used only for the constructor definitions).
This class represents the member function being called and must be assembled in the SgFunctionCall wi...
SgMemberFunctionSymbol * p_symbol_i
This is the SgMemberFunctionSymbol.
SgFunctionType * p_function_type
This is a pointer to the SgFunctionType associated with this member function reference.
int p_need_qualifier
This boolean value marks if name qualification is required.
int p_virtual_call
This boolean value marks if the function reference is a virtual function.
This class represents the numeric negation of a value. Not to be confused with SgSubtractOp.
This class is not used in ROSE, but is intended to represent a list of SgModifierTypes (similar to th...
This class represents the base class of a number of IR nodes define modifiers within the C++ grammar.
This class represents strings within the IR nodes.
std::string p_char
This pointer points to an internal C style string.
This class represents the concept of a C++ namespace alias declaration statement.
SgNamespaceDeclarationStatement * p_namespaceDeclaration
This the namespace to which the alis references.
SgName p_name
This the name of the new namespace alias (usually a shorter name).
This class represents the concept of a C++ namespace declaration.
bool p_isUnnamedNamespace
Records special case of an unnamed namespace.
SgName p_name
This the name of the new namespace alias (usually a shorter name).
SgNamespaceDefinitionStatement * p_definition
This pointer points to the SgNamespaceDefinitionStatement, which holds the declarations within the na...
This class represents the concept of a namespace definition.
SgDeclarationStatementPtrList p_declarations
This is an STL list of SgDeclarationStatement objects.
SgNamespaceDeclarationStatement * p_namespaceDeclaration
This is a pointer to the SgNamespaceDeclarationStatement.
This class represents the concept of a namespace name within the compiler.
This class represents the notion of an n-ary boolean operation. This node is intended for use with Py...
This class represents the notion of an n-ary comparison operation. This node is intended for use with...
This class represents the notion of an n-ary operator. This node is intended for use with Python.
SgExpressionPtrList p_operands
This is the list of operands associated with this n-ary operator.
VariantTList p_operators
This is the list of operators associated with this n-ary operator.
This class represents the concept of a C++ call to the new operator.
SgExprListExp * p_placement_args
This is a pointer to the memory allocation placement arguments for the new operator.
short p_need_global_specifier
This new operator needs to be output with "::".
SgExpression * p_builtin_args
This is a pointer to the builtin arguments for the new operator (typically the "this" pointer where s...
SgConstructorInitializer * p_constructor_args
This is a pointer to the constructor initializer (which holds its constructor arguments) for the new ...
This class represents the base class for all IR nodes within Sage III.
SgNode * p_parent
This is the pointer to the parent IR node in the AST.
bool p_isModified
Records if IR node has been modified (data members reset).
SgNode * p_freepointer
This is the pointer to the chain of previously freed objects.
omp_default_option_enum
OpenMP default clause values.
This class represents an object used to initialize the unparsing.
This class represents a Fortran pointer assignment. It is not some weird compound assignment operator...
This class represents the concept of a C Assembler statement (untested).
subprogram_kind_enum
Classification for different types of Fortran subprograms.
This class represents a source project, with a list of SgFile objects and global information about th...
SgStringList p_librarySpecifierList
List of libraries specified using "-lxxx" syntax.
bool p_prelink
This controls if we are to handle the prelink (not implemented).
bool p_openmp_linking
This flag is used to indicate if OpenMP lowering is requested by the command line so linking to ROSE'...
SgStringList p_includeDirectorySpecifierList
List of directories specified with "-I" option on command line.
SgStringList p_objectFileNameList
List of all object files specified on the command line.
SgStringList p_originalCommandLineArgumentList
Copy of original argc and argv command line passed to ROSE translator (converted to STL list of strin...
SgProject::template_instantiation_enum p_template_instantiation_mode
This controls the degree of template instantiation by ROSE. No template instantiation is required by ...
template_instantiation_enum
int p_backendErrorCode
Error code returnd from processing of generated source code using vendor compiler.
SgStringList p_libraryFileList
List of all libraries specified on command line.
bool p_compileOnly
This controls if we are to act as a linker (by calling the vendor compiler as a linker/prelinker).
int p_frontendErrorCode
Error code returned from EDG front-end processing.
SgStringList p_sourceFileNameList
List of all source file names specified on the command line.
SgStringList p_libraryDirectorySpecifierList
List of directories specified with "-L" option on command line.
std::string p_outputFileName
Filename specific using "-o" option on command line.
This class represents the concept of a 'global' stmt in Python.
SgInitializedNamePtrList p_names
This is a list of SgInitializedNames that are imported into the inner scope.
This class represents a OLD concept of the structure require for qualified names when they were in th...
This class represents a OLD concept of the structure require for qualified names when they were in th...
This class represents the "&" operator (applied to any lvalue).
SgType * p_type_name
This a SgType, but I forget its significance.
This class represents the concept of a C Assembler statement (untested).
This class was part of CC++ support from a long time ago.
This class represents the concept of a scope in C++ (e.g. global scope, fuction scope,...
SgSymbolTable * p_symbol_table
This pointer is always valid and stores the symbl table.
This class represents the "sizeof()" operator (applied to any type).
SgType * p_expression_type
This a SgType, the type of the expression.
SgType * p_operand_type
This a pointer to the SgType given to the sizeof operator.
SgExpression * p_operand_expr
This a pointer to the expression given to the sizeof operator.
This class is part of the older CC++ concept. It is not a part of C or C++ (this IR node is not used ...
This class represents the GNU extension "statement expression" (thus is non-standard C and C++).
SgStatement * p_statement
This a pointer to the SgStatement (usually a SgBasicBlock).
This class represents the notion of a statement.
This class is intended to be a wrapper around SgStatements, allowing them to exist in scopes that onl...
SgStatement * p_statement
Holds the wrapped statement.
This class represents modifiers specific to storage.
storage_modifier_enum
Storage Modifiers (only one value can be specified)
This class represents the conversion of an arbitrary expression to a string. This node is intended fo...
SgExpression * p_expression
The expression to be converted to a string.
jovial_structure_modifier_enum
Jovial Structure Modifier/Specifier (tight implies serial)
This class represents the base class of a numbr of IR nodes that don't otherwise fit into the existin...
This class represents the concept of a switch.
SgStatement * p_body
This pointer a SgBasicBlock, and holds the cases in the body of the switch.
This class represents the symbol tables used in both SgScopeStatement and the SgFunctionTypeSymbolTab...
SgName p_name
This is the symbol name (mangled is required).
hash_iterator p_iterator
This iterator is used within some of the deprecated functions.
bool p_no_name
This is a flag to indicate that p_name is empty.
rose_hash_multimap * p_table
This is lower level symbol table implementation (using an STL hash_multimap)
This class represents the concept of a name within the compiler.
This class represents template argument within the use of a template to build an instantiation.
bool p_isArrayBoundUnknownType
Template arguments can be used as array bounds, if so this this marks the arguments use as such.
SgType * p_type
This is the template argument's reference to a type (if it is a type).
bool p_explicitlySpecified
This true only if for a function template the argument is explicit in the source code (it need not al...
SgExpression * p_expression
This is the template argument's reference to an expression (if it is an expression).
This class represents the concept of a template declaration.
SgName p_string
This is the full template declaration as a string only.
SgName p_name
This is the name of the template.
SgScopeStatement * p_scope
This is the scope of the template declaration.
SgTemplateParameterPtrList p_templateParameters
This is the STL list of pointers template parameters (SgTemplateParameter objects)
SgTemplateDeclaration::template_type_enum p_template_kind
This is the classification of the template declaration.
This class represents the concept of an instantiated class template.
SgTemplateClassDeclaration * p_templateDeclaration
This is the template declarations (SgTemplateDeclaration) from which this template instantiation is c...
SgTemplateArgumentPtrList p_templateArguments
This is a pointer to a list of pointers to SgTemplateArgument objects (used with the SgTemplateDeclar...
SgName p_templateName
This is the name of the templated class (excludes template arguments)
SgName p_templateHeader
This data field is not used (or is used internally).
bool p_nameResetFromMangledForm
This bool value is set to false at construction and later reset to true within post-processing as eac...
This class represents the concept of a class definition in C++.
This class represents the concept of a C++ template instantiation directive.
SgDeclarationStatement * p_declaration
This pointer points to associated template instantiation declaration meant to be explicitly instantia...
This class represents the concept of an instantiation of function template.
SgTemplateFunctionDeclaration * p_templateDeclaration
This is the template declarations (SgTemplateDeclaration) from which this template instantiation is c...
bool p_nameResetFromMangledForm
This bool value is set to false at construction and later reset to true within post-processing as eac...
SgTemplateArgumentPtrList p_templateArguments
This is a pointer to a list of pointers to SgTemplateArgument objects (used with the SgTemplateDeclar...
SgName p_templateName
This is the name of the templated class (in the form "name<args>")
This class represents the concept of an instantiation of member function template or a member functio...
SgName p_templateName
This is the name of the templated class (in the form "name<args>")
SgTemplateMemberFunctionDeclaration * p_templateDeclaration
This is the template declarations (SgTemplateDeclaration) from which this template instantiation is c...
SgTemplateArgumentPtrList p_templateArguments
This is a pointer to a list of pointers to SgTemplateArgument objects (used with the SgTemplateDeclar...
bool p_nameResetFromMangledForm
This bool value is set to false at construction and later reset to true within post-processing as eac...
This class represents the "this" operator (can be applied to any member data).
int p_pobj_this
This is not used and is related to a flag from CC++.
SgClassSymbol * p_class_symbol
This is the symbol of the class to which the "this" operator is applied.
This class represents the C++ throw expression (handled as a unary operator).
e_throw_kind
Throw IR node can be used in three different ways.
SgThrowOp::e_throw_kind p_throwKind
This enum value classifies the throw as either of three different kinds.
This class represents the concept of try statement within the try-catch support for exception handlin...
SgStatement * p_else_body
This pointer points to a SgBasicBlock containing the statements to be executed when control flows off...
SgStatement * p_finally_body
This pointer points to a SgBasicBlock containing the statements to be executed when an unhandled exce...
SgCatchStatementSeq * p_catch_statement_seq_root
This pointer points to a SgCatchStatementSeq and connects the try statement to the sequence of catch ...
SgStatement * p_body
This pointer points to a SgBasicBlock containing the statements to be execued by the try block.
This class represents a tuple display.
This class represents a C99 complex type.
This class represents a default type used for some IR nodes (see below).
This class represents a C99 complex type.
gnu_extension_machine_mode_enum
GNU Extension Machine Mode type modifiers (only a single value can be specified at one time)
This class represents a string type used for SgStringVal IR node.
This class represents the base class for all types.
SgTypedefSeq * p_typedefs
This points to IR node which holds a list of typedefs where the base_type if this SgType.
SgReferenceType * p_ref_to
This holds the pointer to a SgReferenceType if this type is a reference to another type.
SgModifierNodes * p_modifiers
This points to any SgModifierNodes if this type contains type modifiers.
SgPointerType * p_ptr_to
This holds the pointer to a SgPointerType if this type is a pointer to another type.
int p_substitutedForTemplateParam
This boolean variable marks if the current type was originally a template parameter.
This class represents the notion of a typedef declaration.
SgTypedefType * p_type
This is the resulting type defined by the typedef declaration.
SgType * p_base_type
This is the type being given a new name by the typedef declaration.
bool p_typedefBaseTypeContainsDefiningDeclaration
This flag indicates that the typedef defines a structure.
SgName p_name
This is the name of the newly defined type.
SgScopeStatement * p_scope
This is the scope of the typedef declaration.
SgSymbol * p_parent_scope
This is the type symbol of the class when it is a member type (redundent with the the explicitly stor...
SgDeclarationStatement * p_declaration
pointer to the declaration (typically a SgClassDeclaration).
This class represents a list of associated typedefs for the SgType IR nodes which reference this list...
SgTypePtrList p_typedefs
This holds the STL list of pointers to SgTypes.
upc_access_modifier_enum
UPC Access Modifiers (only one value can be specified)
This class represents the notion of a unary operator. It is derived from a SgExpression because opera...
SgExpression * p_operand_i
This is the operand associated with the unary operator.
Sgop_mode
Enum value defines operators as prefix or postfix, as appropriate, e.g. operator++().
SgUnaryOp::Sgop_mode p_mode
This SgType is the type of the operator (function type).
SgType * p_expression_type
This SgType is the type of the operator (function type).
This class represents the concept of a C++ using declaration.
SgDeclarationStatement * p_declaration
This pointer points to a SgDeclarationStatement whose declaration(s) are available for use in the sco...
SgInitializedName * p_initializedName
This pointer points to a SgDeclarationStatement whose declaration(s) are available for use in the sco...
This class represents the concept of a C++ using directive.
SgNamespaceDeclarationStatement * p_namespaceDeclaration
This pointer points to namespace declaration being used.
This class represents the notion of an value (expression value).
This class represents the variable refernece in expressions.
This class represents the concept of a C or C++ variable declaration.
SgDeclarationStatement::template_specialization_enum p_specialization
This is part of template support (variables of templated types).
SgDeclarationStatement * p_baseTypeDefiningDeclaration
This is used to traverse type definitions within variable declarations.
gnu_extension_declaration_attributes_enum
GNU extension for declaration modifiers (multiple values may be specified)
bool p_variableDeclarationContainsBaseTypeDefiningDeclaration
This bool records if the variable declaration has the explicit defining declaration associated with i...
SgInitializedNamePtrList p_variables
This is an STL list of pointers to SgInitializedName objects.
This class represents the definition (initialization) of a variable.
SgExpression * p_bitfield
This a pointer to a value specifies the bitwidth of the variable (used to control memory layout/paddi...
SgInitializedName * p_vardefn
This pointer points to associated SgInitializedName object (the variable).
This class represents the concept of a variable name within the compiler (a shared container for the ...
This class represents the concept of a do-while statement.
SgStatement * p_condition
This pointer a SgStatement, the conditional expression in the loop construct.
SgStatement * p_body
This pointer a SgBasicBlock, and holds the statements in the body of the loop.
SgStatement * p_else_body
This pointer to an SgStatement holds the body of the 'else' block.
This class represents the location of the code associated with the IR node in the original source cod...
unsigned int p_classificationBitField
This is mechanism for classification of the IR node.
int p_file_id
This is a key that maps integers to file names, it prevents redundent storage of filename strings.
SgFileIdList p_fileIDsToUnparse
This set contains a list of all file ids for which the accompanying IR node should be unparsed.
int p_col
This is the column number of the location of the source code for this IR node.
int p_line
This is the line number of the location of the source code for this IR node.
Hash table support for symbol tables within ROSE.
Sawyer::Container::IntervalSet< AddressInterval > AddressIntervalSet
A set of virtual addresses.
X86InstructionKind
List of all x86 instructions known to the ROSE disassembler/assembler.
std::uint64_t Address
Address.
Definition Address.h:11
The ROSE library.
Sawyer support library.
A template list implementing a apply pattern (functor return void but does not have to be pure)
Definition metaprog.h:79