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> {
8 using parent = SgAccessModifier;
9 using field_type = SgAccessModifier::access_modifier_enum;
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};
24 using subclasses_t = mp::List<>;
25 using fields_t = mp::List<describe_field_t<SgAccessModifier,SgAccessModifier::access_modifier_enum,&SgAccessModifier::p_modifier>>;
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> {
31 using parent = SgActualArgumentExpression;
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> {
42 using parent = SgActualArgumentExpression;
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};
52template <> struct describe_node_t<SgActualArgumentExpression> {
53 using node = SgActualArgumentExpression;
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};
58 using subclasses_t = mp::List<>;
59 using fields_t = mp::List<describe_field_t<SgActualArgumentExpression,SgName,&SgActualArgumentExpression::p_argument_name>, describe_field_t<SgActualArgumentExpression,SgExpression*,&SgActualArgumentExpression::p_expression>>;
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};
70 using subclasses_t = mp::List<>;
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<>;
116 using fields_t = mp::List<describe_field_t<SgAdaAccessType,SgType*,&SgAdaAccessType::p_base_type>, describe_field_t<SgAdaAccessType,bool,&SgAdaAccessType::p_is_general_access>, describe_field_t<SgAdaAccessType,bool,&SgAdaAccessType::p_is_anonymous>>;
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;
123 using field_type = SgFunctionParameterScope*;
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;
134 using field_type = SgFunctionParameterList*;
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<>;
217 using fields_t = mp::List<describe_field_t<SgAdaDelayStmt,SgExpression*,&SgAdaDelayStmt::p_time>, describe_field_t<SgAdaDelayStmt,bool,&SgAdaDelayStmt::p_isRelative>>;
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;
224 using field_type = SgInitializedName*;
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;
246 using base = SgFunctionDeclaration;
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<>;
251 using fields_t = mp::List<describe_field_t<SgAdaEntryDecl,SgInitializedName*,&SgAdaEntryDecl::p_entryIndex>, describe_field_t<SgAdaEntryDecl,SgExpression*,&SgAdaEntryDecl::p_entryBarrier>>;
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<>;
296 using fields_t = mp::List<describe_field_t<SgAdaExitStmt,SgStatement*,&SgAdaExitStmt::p_loop>, describe_field_t<SgAdaExitStmt,SgExpression*,&SgAdaExitStmt::p_condition>, describe_field_t<SgAdaExitStmt,bool,&SgAdaExitStmt::p_explicitLoopName>>;
297};
298template <> struct node_from_variant_t<8> { using type = SgAdaExitStmt; };
299
300// Class: AdaDiscreteType
301template <> struct describe_node_t<SgAdaDiscreteType> {
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<>;
331 using fields_t = mp::List<describe_field_t<SgAdaFloatVal,std::string,&SgAdaFloatVal::p_valueString>>;
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<>;
365 using fields_t = mp::List<describe_field_t<SgAdaLoopStmt,SgBasicBlock*,&SgAdaLoopStmt::p_body>, describe_field_t<SgAdaLoopStmt,std::string,&SgAdaLoopStmt::p_string_label>>;
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};
381template <> struct describe_node_t<SgAdaPackageBody> {
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<>;
388 using fields_t = mp::List<describe_field_t<SgAdaPackageBody,SgStatementPtrList,&SgAdaPackageBody::p_statements>>;
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> {
394 using parent = SgAdaPackageBodyDecl;
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> {
405 using parent = SgAdaPackageBodyDecl;
406 using field_type = SgAdaPackageBody*;
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> {
416 using parent = SgAdaPackageBodyDecl;
417 using field_type = SgScopeStatement*;
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> {
427 using parent = SgAdaPackageBodyDecl;
428 using field_type = SgAdaPackageSpecDecl*;
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};
471template <> struct describe_node_t<SgAdaPackageSpec> {
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<>;
478 using fields_t = mp::List<describe_field_t<SgAdaPackageSpec,bool,&SgAdaPackageSpec::p_hasPrivate>, describe_field_t<SgAdaPackageSpec,SgDeclarationStatementPtrList,&SgAdaPackageSpec::p_declarations>>;
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> {
484 using parent = SgAdaPackageSpecDecl;
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> {
495 using parent = SgAdaPackageSpecDecl;
496 using field_type = SgAdaPackageSpec*;
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> {
506 using parent = SgAdaPackageSpecDecl;
507 using field_type = SgScopeStatement*;
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> {
517 using parent = SgAdaPackageSpecDecl;
518 using field_type = SgAdaPackageBodyDecl*;
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> {
540 using parent = SgAdaPackageSymbol;
541 using field_type = SgDeclarationStatement*;
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};
550template <> struct describe_node_t<SgAdaPackageSymbol> {
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<>;
557 using fields_t = mp::List<describe_field_t<SgAdaPackageSymbol,SgDeclarationStatement*,&SgAdaPackageSymbol::p_declaration>>;
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> {
563 using parent = SgAdaRangeConstraint;
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};
573template <> struct describe_node_t<SgAdaRangeConstraint> {
574 using node = SgAdaRangeConstraint;
575 using base = SgAdaTypeConstraint;
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<>;
580 using fields_t = mp::List<describe_field_t<SgAdaRangeConstraint,SgExpression*,&SgAdaRangeConstraint::p_range>>;
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> {
586 using parent = SgAdaRenamingDecl;
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> {
597 using parent = SgAdaRenamingDecl;
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> {
608 using parent = SgAdaRenamingDecl;
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};
618template <> struct describe_node_t<SgAdaRenamingDecl> {
619 using node = SgAdaRenamingDecl;
620 using base = SgDeclarationStatement;
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<>;
625 using fields_t = mp::List<describe_field_t<SgAdaRenamingDecl,SgName,&SgAdaRenamingDecl::p_name>, describe_field_t<SgAdaRenamingDecl,SgExpression*,&SgAdaRenamingDecl::p_renamed>, describe_field_t<SgAdaRenamingDecl,SgType*,&SgAdaRenamingDecl::p_type>>;
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;
643 using field_type = SgAdaTypeConstraint*;
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<>;
670 using fields_t = mp::List<describe_field_t<SgAdaSubtype,SgType*,&SgAdaSubtype::p_base_type>, describe_field_t<SgAdaSubtype,SgAdaTypeConstraint*,&SgAdaSubtype::p_constraint>, describe_field_t<SgAdaSubtype,bool,&SgAdaSubtype::p_fromRootType>>;
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<>;
704 using fields_t = mp::List<describe_field_t<SgAdaTaskBody,SgAdaTaskSpec*,&SgAdaTaskBody::p_spec>, describe_field_t<SgAdaTaskBody,SgStatementPtrList,&SgAdaTaskBody::p_statements>>;
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> {
710 using parent = SgAdaTaskBodyDecl;
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> {
721 using parent = SgAdaTaskBodyDecl;
722 using field_type = SgDeclarationStatement*;
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> {
732 using parent = SgAdaTaskBodyDecl;
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<>;
794 using fields_t = mp::List<describe_field_t<SgAdaTaskSpec,SgAdaTaskBody*,&SgAdaTaskSpec::p_body>, describe_field_t<SgAdaTaskSpec,SgDeclarationStatementPtrList,&SgAdaTaskSpec::p_declarations>, describe_field_t<SgAdaTaskSpec,bool,&SgAdaTaskSpec::p_hasPrivate>>;
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> {
800 using parent = SgAdaTaskSpecDecl;
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> {
811 using parent = SgAdaTaskSpecDecl;
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> {
822 using parent = SgAdaTaskSpecDecl;
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};
832template <> struct describe_node_t<SgAdaTaskSpecDecl> {
833 using node = SgAdaTaskSpecDecl;
834 using base = SgDeclarationStatement;
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<>;
839 using fields_t = mp::List<describe_field_t<SgAdaTaskSpecDecl,SgName,&SgAdaTaskSpecDecl::p_name>, describe_field_t<SgAdaTaskSpecDecl,SgAdaTaskSpec*,&SgAdaTaskSpecDecl::p_definition>, describe_field_t<SgAdaTaskSpecDecl,SgAdaTaskType*,&SgAdaTaskSpecDecl::p_type>>;
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;
846 using field_type = SgDeclarationStatement*;
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<>;
862 using fields_t = mp::List<describe_field_t<SgAdaTaskSymbol,SgDeclarationStatement*,&SgAdaTaskSymbol::p_declaration>>;
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;
869 using field_type = SgAdaTaskSymbol*;
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<>;
885 using fields_t = mp::List<describe_field_t<SgAdaTaskRefExp,SgAdaTaskSymbol*,&SgAdaTaskRefExp::p_symbol>>;
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> {
903 using parent = SgAdaTaskTypeDecl;
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> {
914 using parent = SgAdaTaskTypeDecl;
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> {
925 using parent = SgAdaTaskTypeDecl;
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> {
936 using parent = SgAdaTaskTypeDecl;
937 using field_type = SgScopeStatement*;
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
958template <> struct describe_node_t<SgAdaTypeConstraint> {
959 using node = SgAdaTypeConstraint;
960 using base = SgLocatedNodeSupport;
961 static constexpr char const * const name{"AdaTypeConstraint"};
962 static constexpr unsigned long variant{28};
963 static constexpr bool concrete{false};
964 using subclasses_t = mp::List<SgAdaRangeConstraint, SgAdaIndexConstraint, SgAdaDigitsConstraint, SgAdaDeltaConstraint, SgAdaDiscriminantConstraint, SgAdaNullConstraint>;
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<>;
1000 using fields_t = mp::List<describe_field_t<SgAddressOfOp,SgExpression*,&SgAddressOfOp::p_originalExpressionTree>>;
1001};
1002template <> struct node_from_variant_t<30> { using type = SgAddressOfOp; };
1003
1004// Class: AggregateInitializer
1005template <> struct describe_field_t<SgAggregateInitializer,SgExprListExp*,&SgAggregateInitializer::p_initializers> {
1006 using parent = SgAggregateInitializer;
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> {
1017 using parent = SgAggregateInitializer;
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> {
1028 using parent = SgAggregateInitializer;
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> {
1039 using parent = SgAggregateInitializer;
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> {
1050 using parent = SgAggregateInitializer;
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> {
1061 using parent = SgAggregateInitializer;
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> {
1072 using parent = SgAggregateInitializer;
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> {
1083 using parent = SgAggregateInitializer;
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> {
1094 using parent = SgAggregateInitializer;
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<>;
1167 using fields_t = mp::List<describe_field_t<SgAliasSymbol,SgSymbol*,&SgAliasSymbol::p_alias>, describe_field_t<SgAliasSymbol,bool,&SgAliasSymbol::p_isRenamed>, describe_field_t<SgAliasSymbol,SgName,&SgAliasSymbol::p_new_name>, describe_field_t<SgAliasSymbol,SgNodePtrList,&SgAliasSymbol::p_causal_nodes>>;
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> {
1173 using parent = SgAllocateStatement;
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> {
1184 using parent = SgAllocateStatement;
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> {
1195 using parent = SgAllocateStatement;
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> {
1206 using parent = SgAllocateStatement;
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> {
1253 using parent = SgArithmeticIfStatement;
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> {
1264 using parent = SgArithmeticIfStatement;
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> {
1275 using parent = SgArithmeticIfStatement;
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> {
1286 using parent = SgArithmeticIfStatement;
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};
1421template <> struct describe_node_t<SgAsmBasicString> {
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<>;
1428 using fields_t = mp::List<describe_field_t<SgAsmBasicString,std::string,&SgAsmBasicString::p_string>>;
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;
1435 using base = SgAsmBinaryExpression;
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;
1447 using base = SgAsmBinaryExpression;
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
1457template <> struct describe_node_t<SgAsmBinaryDivide> {
1458 using node = SgAsmBinaryDivide;
1459 using base = SgAsmBinaryExpression;
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> {
1470 using parent = SgAsmBinaryExpression;
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> {
1481 using parent = SgAsmBinaryExpression;
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;
1505 using base = SgAsmBinaryExpression;
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;
1517 using base = SgAsmBinaryExpression;
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;
1529 using base = SgAsmBinaryExpression;
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;
1541 using base = SgAsmBinaryExpression;
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
1551template <> struct describe_node_t<SgAsmBinaryMultiply> {
1552 using node = SgAsmBinaryMultiply;
1553 using base = SgAsmBinaryExpression;
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;
1565 using base = SgAsmBinaryExpression;
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
1575template <> struct describe_node_t<SgAsmBinarySubtract> {
1576 using node = SgAsmBinarySubtract;
1577 using base = SgAsmBinaryExpression;
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
1698template <> struct describe_node_t<SgAsmCoffStrtab> {
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> {
1800 using parent = SgAsmCoffSymbolList;
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};
1810template <> struct describe_node_t<SgAsmCoffSymbolList> {
1811 using node = SgAsmCoffSymbolList;
1812 using base = SgAsmExecutableFileFormat;
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<>;
1817 using fields_t = mp::List<describe_field_t<SgAsmCoffSymbolList,SgAsmCoffSymbolPtrList,&SgAsmCoffSymbolList::p_symbols>>;
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> {
1823 using parent = SgAsmCoffSymbolTable;
1824 using field_type = SgAsmGenericSection*;
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> {
1834 using parent = SgAsmCoffSymbolTable;
1835 using field_type = SgAsmCoffSymbolList*;
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};
1844template <> struct describe_node_t<SgAsmCoffSymbolTable> {
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<>;
1851 using fields_t = mp::List<describe_field_t<SgAsmCoffSymbolTable,SgAsmGenericSection*,&SgAsmCoffSymbolTable::p_strtab>, describe_field_t<SgAsmCoffSymbolTable,SgAsmCoffSymbolList*,&SgAsmCoffSymbolTable::p_symbols>>;
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> {
1857 using parent = SgAsmCommonSubExpression;
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};
1867template <> struct describe_node_t<SgAsmCommonSubExpression> {
1868 using node = SgAsmCommonSubExpression;
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<>;
1874 using fields_t = mp::List<describe_field_t<SgAsmCommonSubExpression,SgAsmExpression*,&SgAsmCommonSubExpression::p_subexpression>>;
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> {
1880 using parent = SgAsmControlFlagsExpression;
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};
1890template <> struct describe_node_t<SgAsmControlFlagsExpression> {
1891 using node = SgAsmControlFlagsExpression;
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<>;
1897 using fields_t = mp::List<describe_field_t<SgAsmControlFlagsExpression,unsigned long,&SgAsmControlFlagsExpression::p_bitFlags>>;
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> {
1903 using parent = SgAsmConstantExpression;
1904 using field_type = Sawyer::Container::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};
1913template <> struct describe_node_t<SgAsmConstantExpression> {
1914 using node = SgAsmConstantExpression;
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};
1919 using subclasses_t = mp::List<SgAsmFloatValueExpression, SgAsmIntegerValueExpression>;
1920 using fields_t = mp::List<describe_field_t<SgAsmConstantExpression,Sawyer::Container::BitVector,&SgAsmConstantExpression::p_bitVector>>;
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> {
1926 using parent = SgAsmDOSExtendedHeader;
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> {
1937 using parent = SgAsmDOSExtendedHeader;
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> {
1948 using parent = SgAsmDOSExtendedHeader;
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> {
1959 using parent = SgAsmDOSExtendedHeader;
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> {
1970 using parent = SgAsmDOSExtendedHeader;
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> {
1981 using parent = SgAsmDOSExtendedHeader;
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> {
1992 using parent = SgAsmDOSExtendedHeader;
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> {
2003 using parent = SgAsmDOSExtendedHeader;
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> {
2014 using parent = SgAsmDOSExtendedHeader;
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;
2192 using field_type = SgAsmGenericSection*;
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;
2203 using field_type = SgAsmGenericSection*;
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};
2212template <> struct describe_node_t<SgAsmDOSFileHeader> {
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<>;
2219 using fields_t = mp::List<describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_last_page_size>, describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_total_pages>, describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_nrelocs>, describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_header_paragraphs>, describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_minalloc>, describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_maxalloc>, describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_ss>, describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_sp>, describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_cksum>, describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_ip>, describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_cs>, describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_overlay>, describe_field_t<SgAsmDOSFileHeader,Rose::BinaryAnalysis::Address,&SgAsmDOSFileHeader::p_e_relocs_offset>, describe_field_t<SgAsmDOSFileHeader,unsigned,&SgAsmDOSFileHeader::p_e_res1>, describe_field_t<SgAsmDOSFileHeader,SgAsmGenericSection*,&SgAsmDOSFileHeader::p_relocs>, describe_field_t<SgAsmDOSFileHeader,SgAsmGenericSection*,&SgAsmDOSFileHeader::p_rm_section>>;
2220};
2221template <> struct node_from_variant_t<71> { using type = SgAsmDOSFileHeader; };
2222
2223// Class: AsmSynthesizedDataStructureDeclaration
2224template <> struct describe_node_t<SgAsmSynthesizedDataStructureDeclaration> {
2225 using node = SgAsmSynthesizedDataStructureDeclaration;
2226 using base = SgAsmSynthesizedDeclaration;
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
2236template <> struct describe_node_t<SgAsmSynthesizedDeclaration> {
2237 using node = SgAsmSynthesizedDeclaration;
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};
2242 using subclasses_t = mp::List<SgAsmFunction, SgAsmSynthesizedDataStructureDeclaration, SgAsmSynthesizedFieldDeclaration>;
2243 using fields_t = mp::List<>;
2244};
2245template <> struct node_from_variant_t<73> { using type = SgAsmSynthesizedDeclaration; };
2246
2247// Class: AsmDirectRegisterExpression
2248template <> struct describe_node_t<SgAsmDirectRegisterExpression> {
2249 using node = SgAsmDirectRegisterExpression;
2250 using base = SgAsmRegisterReferenceExpression;
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
2260template <> struct describe_node_t<SgAsmDwarfAccessDeclaration> {
2261 using node = SgAsmDwarfAccessDeclaration;
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> {
2273 using parent = SgAsmDwarfArrayType;
2274 using field_type = SgAsmDwarfConstructList*;
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};
2283template <> struct describe_node_t<SgAsmDwarfArrayType> {
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<>;
2290 using fields_t = mp::List<describe_field_t<SgAsmDwarfArrayType,SgAsmDwarfConstructList*,&SgAsmDwarfArrayType::p_body>>;
2291};
2292template <> struct node_from_variant_t<76> { using type = SgAsmDwarfArrayType; };
2293
2294// Class: AsmDwarfBaseType
2295template <> struct describe_node_t<SgAsmDwarfBaseType> {
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
2307template <> struct describe_node_t<SgAsmDwarfCatchBlock> {
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
2319template <> struct describe_node_t<SgAsmDwarfClassTemplate> {
2320 using node = SgAsmDwarfClassTemplate;
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> {
2332 using parent = SgAsmDwarfClassType;
2333 using field_type = SgAsmDwarfConstructList*;
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};
2342template <> struct describe_node_t<SgAsmDwarfClassType> {
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<>;
2349 using fields_t = mp::List<describe_field_t<SgAsmDwarfClassType,SgAsmDwarfConstructList*,&SgAsmDwarfClassType::p_body>>;
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> {
2355 using parent = SgAsmDwarfCommonBlock;
2356 using field_type = SgAsmDwarfConstructList*;
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};
2365template <> struct describe_node_t<SgAsmDwarfCommonBlock> {
2366 using node = SgAsmDwarfCommonBlock;
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<>;
2372 using fields_t = mp::List<describe_field_t<SgAsmDwarfCommonBlock,SgAsmDwarfConstructList*,&SgAsmDwarfCommonBlock::p_body>>;
2373};
2374template <> struct node_from_variant_t<81> { using type = SgAsmDwarfCommonBlock; };
2375
2376// Class: AsmDwarfCommonInclusion
2377template <> struct describe_node_t<SgAsmDwarfCommonInclusion> {
2378 using node = SgAsmDwarfCommonInclusion;
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> {
2390 using parent = SgAsmDwarfCompilationUnit;
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> {
2401 using parent = SgAsmDwarfCompilationUnit;
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> {
2412 using parent = SgAsmDwarfCompilationUnit;
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> {
2423 using parent = SgAsmDwarfCompilationUnit;
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> {
2434 using parent = SgAsmDwarfCompilationUnit;
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> {
2445 using parent = SgAsmDwarfCompilationUnit;
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> {
2456 using parent = SgAsmDwarfCompilationUnit;
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> {
2467 using parent = SgAsmDwarfCompilationUnit;
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> {
2478 using parent = SgAsmDwarfCompilationUnit;
2479 using field_type = SgAsmDwarfLineList*;
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> {
2489 using parent = SgAsmDwarfCompilationUnit;
2490 using field_type = SgAsmDwarfConstructList*;
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> {
2500 using parent = SgAsmDwarfCompilationUnit;
2501 using field_type = SgAsmDwarfMacroList*;
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> {
2523 using parent = SgAsmDwarfCompilationUnitList;
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};
2533template <> struct describe_node_t<SgAsmDwarfCompilationUnitList> {
2534 using node = SgAsmDwarfCompilationUnitList;
2535 using base = SgAsmDwarfInformation;
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<>;
2540 using fields_t = mp::List<describe_field_t<SgAsmDwarfCompilationUnitList,SgAsmDwarfCompilationUnitPtrList,&SgAsmDwarfCompilationUnitList::p_cu_list>>;
2541};
2542template <> struct node_from_variant_t<84> { using type = SgAsmDwarfCompilationUnitList; };
2543
2544// Class: AsmDwarfCondition
2545template <> struct describe_node_t<SgAsmDwarfCondition> {
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
2557template <> struct describe_node_t<SgAsmDwarfConstType> {
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
2569template <> struct describe_node_t<SgAsmDwarfConstant> {
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> {
2582 using parent = SgAsmDwarfConstruct;
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> {
2593 using parent = SgAsmDwarfConstruct;
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> {
2604 using parent = SgAsmDwarfConstruct;
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> {
2615 using parent = SgAsmDwarfConstruct;
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> {
2626 using parent = SgAsmDwarfConstruct;
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};
2636template <> struct describe_node_t<SgAsmDwarfConstruct> {
2637 using node = SgAsmDwarfConstruct;
2638 using base = SgAsmDwarfInformation;
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>;
2643 using fields_t = mp::List<describe_field_t<SgAsmDwarfConstruct,int,&SgAsmDwarfConstruct::p_nesting_level>, describe_field_t<SgAsmDwarfConstruct,uint64_t,&SgAsmDwarfConstruct::p_offset>, describe_field_t<SgAsmDwarfConstruct,uint64_t,&SgAsmDwarfConstruct::p_overall_offset>, describe_field_t<SgAsmDwarfConstruct,std::string,&SgAsmDwarfConstruct::p_name>, describe_field_t<SgAsmDwarfConstruct,SgAsmDwarfLine*,&SgAsmDwarfConstruct::p_source_position>>;
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> {
2649 using parent = SgAsmDwarfConstructList;
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};
2659template <> struct describe_node_t<SgAsmDwarfConstructList> {
2660 using node = SgAsmDwarfConstructList;
2661 using base = SgAsmDwarfInformation;
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<>;
2666 using fields_t = mp::List<describe_field_t<SgAsmDwarfConstructList,SgAsmDwarfConstructPtrList,&SgAsmDwarfConstructList::p_list>>;
2667};
2668template <> struct node_from_variant_t<89> { using type = SgAsmDwarfConstructList; };
2669
2670// Class: AsmDwarfDwarfProcedure
2671template <> struct describe_node_t<SgAsmDwarfDwarfProcedure> {
2672 using node = SgAsmDwarfDwarfProcedure;
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
2683template <> struct describe_node_t<SgAsmDwarfEntryPoint> {
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> {
2696 using parent = SgAsmDwarfEnumerationType;
2697 using field_type = SgAsmDwarfConstructList*;
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};
2706template <> struct describe_node_t<SgAsmDwarfEnumerationType> {
2707 using node = SgAsmDwarfEnumerationType;
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<>;
2713 using fields_t = mp::List<describe_field_t<SgAsmDwarfEnumerationType,SgAsmDwarfConstructList*,&SgAsmDwarfEnumerationType::p_body>>;
2714};
2715template <> struct node_from_variant_t<92> { using type = SgAsmDwarfEnumerationType; };
2716
2717// Class: AsmDwarfEnumerator
2718template <> struct describe_node_t<SgAsmDwarfEnumerator> {
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
2730template <> struct describe_node_t<SgAsmDwarfFileType> {
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
2742template <> struct describe_node_t<SgAsmDwarfFormalParameter> {
2743 using node = SgAsmDwarfFormalParameter;
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
2754template <> struct describe_node_t<SgAsmDwarfFormatLabel> {
2755 using node = SgAsmDwarfFormatLabel;
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
2766template <> struct describe_node_t<SgAsmDwarfFriend> {
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
2778template <> struct describe_node_t<SgAsmDwarfFunctionTemplate> {
2779 using node = SgAsmDwarfFunctionTemplate;
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
2790template <> struct describe_node_t<SgAsmDwarfImportedDeclaration> {
2791 using node = SgAsmDwarfImportedDeclaration;
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
2802template <> struct describe_node_t<SgAsmDwarfImportedModule> {
2803 using node = SgAsmDwarfImportedModule;
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
2814template <> struct describe_node_t<SgAsmDwarfImportedUnit> {
2815 using node = SgAsmDwarfImportedUnit;
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
2826template <> struct describe_node_t<SgAsmDwarfInformation> {
2827 using node = SgAsmDwarfInformation;
2828 using base = SgAsmExecutableFileFormat;
2829 static constexpr char const * const name{"AsmDwarfInformation"};
2830 static constexpr unsigned long variant{102};
2831 static constexpr bool concrete{false};
2832 using subclasses_t = mp::List<SgAsmDwarfCompilationUnitList, SgAsmDwarfConstruct, SgAsmDwarfConstructList, SgAsmDwarfLine, SgAsmDwarfLineList, SgAsmDwarfMacro, SgAsmDwarfMacroList>;
2833 using fields_t = mp::List<>;
2834};
2835template <> struct node_from_variant_t<102> { using type = SgAsmDwarfInformation; };
2836
2837// Class: AsmDwarfInheritance
2838template <> struct describe_node_t<SgAsmDwarfInheritance> {
2839 using node = SgAsmDwarfInheritance;
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> {
2851 using parent = SgAsmDwarfInlinedSubroutine;
2852 using field_type = SgAsmDwarfConstructList*;
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};
2861template <> struct describe_node_t<SgAsmDwarfInlinedSubroutine> {
2862 using node = SgAsmDwarfInlinedSubroutine;
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<>;
2868 using fields_t = mp::List<describe_field_t<SgAsmDwarfInlinedSubroutine,SgAsmDwarfConstructList*,&SgAsmDwarfInlinedSubroutine::p_body>>;
2869};
2870template <> struct node_from_variant_t<104> { using type = SgAsmDwarfInlinedSubroutine; };
2871
2872// Class: AsmDwarfInterfaceType
2873template <> struct describe_node_t<SgAsmDwarfInterfaceType> {
2874 using node = SgAsmDwarfInterfaceType;
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
2885template <> struct describe_node_t<SgAsmDwarfLabel> {
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> {
2898 using parent = SgAsmDwarfLexicalBlock;
2899 using field_type = SgAsmDwarfConstructList*;
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};
2908template <> struct describe_node_t<SgAsmDwarfLexicalBlock> {
2909 using node = SgAsmDwarfLexicalBlock;
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<>;
2915 using fields_t = mp::List<describe_field_t<SgAsmDwarfLexicalBlock,SgAsmDwarfConstructList*,&SgAsmDwarfLexicalBlock::p_body>>;
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;
2966 using base = SgAsmDwarfInformation;
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<>;
2971 using fields_t = mp::List<describe_field_t<SgAsmDwarfLine,uint64_t,&SgAsmDwarfLine::p_address>, describe_field_t<SgAsmDwarfLine,int,&SgAsmDwarfLine::p_file_id>, describe_field_t<SgAsmDwarfLine,int,&SgAsmDwarfLine::p_line>, describe_field_t<SgAsmDwarfLine,int,&SgAsmDwarfLine::p_column>>;
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};
2987template <> struct describe_node_t<SgAsmDwarfLineList> {
2988 using node = SgAsmDwarfLineList;
2989 using base = SgAsmDwarfInformation;
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<>;
2994 using fields_t = mp::List<describe_field_t<SgAsmDwarfLineList,SgAsmDwarfLinePtrList,&SgAsmDwarfLineList::p_line_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};
3010template <> struct describe_node_t<SgAsmDwarfMacro> {
3011 using node = SgAsmDwarfMacro;
3012 using base = SgAsmDwarfInformation;
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<>;
3017 using fields_t = mp::List<describe_field_t<SgAsmDwarfMacro,std::string,&SgAsmDwarfMacro::p_macro_string>>;
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> {
3023 using parent = SgAsmDwarfMacroList;
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};
3033template <> struct describe_node_t<SgAsmDwarfMacroList> {
3034 using node = SgAsmDwarfMacroList;
3035 using base = SgAsmDwarfInformation;
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<>;
3040 using fields_t = mp::List<describe_field_t<SgAsmDwarfMacroList,SgAsmDwarfMacroPtrList,&SgAsmDwarfMacroList::p_macro_list>>;
3041};
3042template <> struct node_from_variant_t<111> { using type = SgAsmDwarfMacroList; };
3043
3044// Class: AsmDwarfMember
3045template <> struct describe_node_t<SgAsmDwarfMember> {
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
3057template <> struct describe_node_t<SgAsmDwarfModule> {
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
3069template <> struct describe_node_t<SgAsmDwarfMutableType> {
3070 using node = SgAsmDwarfMutableType;
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
3081template <> struct describe_node_t<SgAsmDwarfNamelist> {
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
3093template <> struct describe_node_t<SgAsmDwarfNamelistItem> {
3094 using node = SgAsmDwarfNamelistItem;
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> {
3106 using parent = SgAsmDwarfNamespace;
3107 using field_type = SgAsmDwarfConstructList*;
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};
3116template <> struct describe_node_t<SgAsmDwarfNamespace> {
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<>;
3123 using fields_t = mp::List<describe_field_t<SgAsmDwarfNamespace,SgAsmDwarfConstructList*,&SgAsmDwarfNamespace::p_body>>;
3124};
3125template <> struct node_from_variant_t<117> { using type = SgAsmDwarfNamespace; };
3126
3127// Class: AsmDwarfPackedType
3128template <> struct describe_node_t<SgAsmDwarfPackedType> {
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
3140template <> struct describe_node_t<SgAsmDwarfPartialUnit> {
3141 using node = SgAsmDwarfPartialUnit;
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
3152template <> struct describe_node_t<SgAsmDwarfPointerType> {
3153 using node = SgAsmDwarfPointerType;
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
3164template <> struct describe_node_t<SgAsmDwarfPtrToMemberType> {
3165 using node = SgAsmDwarfPtrToMemberType;
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
3176template <> struct describe_node_t<SgAsmDwarfReferenceType> {
3177 using node = SgAsmDwarfReferenceType;
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
3188template <> struct describe_node_t<SgAsmDwarfRestrictType> {
3189 using node = SgAsmDwarfRestrictType;
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
3200template <> struct describe_node_t<SgAsmDwarfSetType> {
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
3212template <> struct describe_node_t<SgAsmDwarfSharedType> {
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
3224template <> struct describe_node_t<SgAsmDwarfStringType> {
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> {
3237 using parent = SgAsmDwarfStructureType;
3238 using field_type = SgAsmDwarfConstructList*;
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};
3247template <> struct describe_node_t<SgAsmDwarfStructureType> {
3248 using node = SgAsmDwarfStructureType;
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<>;
3254 using fields_t = mp::List<describe_field_t<SgAsmDwarfStructureType,SgAsmDwarfConstructList*,&SgAsmDwarfStructureType::p_body>>;
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> {
3260 using parent = SgAsmDwarfSubprogram;
3261 using field_type = SgAsmDwarfConstructList*;
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};
3270template <> struct describe_node_t<SgAsmDwarfSubprogram> {
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<>;
3277 using fields_t = mp::List<describe_field_t<SgAsmDwarfSubprogram,SgAsmDwarfConstructList*,&SgAsmDwarfSubprogram::p_body>>;
3278};
3279template <> struct node_from_variant_t<128> { using type = SgAsmDwarfSubprogram; };
3280
3281// Class: AsmDwarfSubrangeType
3282template <> struct describe_node_t<SgAsmDwarfSubrangeType> {
3283 using node = SgAsmDwarfSubrangeType;
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> {
3295 using parent = SgAsmDwarfSubroutineType;
3296 using field_type = SgAsmDwarfConstructList*;
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};
3305template <> struct describe_node_t<SgAsmDwarfSubroutineType> {
3306 using node = SgAsmDwarfSubroutineType;
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<>;
3312 using fields_t = mp::List<describe_field_t<SgAsmDwarfSubroutineType,SgAsmDwarfConstructList*,&SgAsmDwarfSubroutineType::p_body>>;
3313};
3314template <> struct node_from_variant_t<130> { using type = SgAsmDwarfSubroutineType; };
3315
3316// Class: AsmDwarfTemplateTypeParameter
3317template <> struct describe_node_t<SgAsmDwarfTemplateTypeParameter> {
3318 using node = SgAsmDwarfTemplateTypeParameter;
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
3329template <> struct describe_node_t<SgAsmDwarfTemplateValueParameter> {
3330 using node = SgAsmDwarfTemplateValueParameter;
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
3341template <> struct describe_node_t<SgAsmDwarfThrownType> {
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
3353template <> struct describe_node_t<SgAsmDwarfTryBlock> {
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
3365template <> struct describe_node_t<SgAsmDwarfTypedef> {
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> {
3378 using parent = SgAsmDwarfUnionType;
3379 using field_type = SgAsmDwarfConstructList*;
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};
3388template <> struct describe_node_t<SgAsmDwarfUnionType> {
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<>;
3395 using fields_t = mp::List<describe_field_t<SgAsmDwarfUnionType,SgAsmDwarfConstructList*,&SgAsmDwarfUnionType::p_body>>;
3396};
3397template <> struct node_from_variant_t<136> { using type = SgAsmDwarfUnionType; };
3398
3399// Class: AsmDwarfUnknownConstruct
3400template <> struct describe_node_t<SgAsmDwarfUnknownConstruct> {
3401 using node = SgAsmDwarfUnknownConstruct;
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
3412template <> struct describe_node_t<SgAsmDwarfUnspecifiedParameters> {
3413 using node = SgAsmDwarfUnspecifiedParameters;
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
3424template <> struct describe_node_t<SgAsmDwarfUnspecifiedType> {
3425 using node = SgAsmDwarfUnspecifiedType;
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
3436template <> struct describe_node_t<SgAsmDwarfUpcRelaxedType> {
3437 using node = SgAsmDwarfUpcRelaxedType;
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
3448template <> struct describe_node_t<SgAsmDwarfUpcSharedType> {
3449 using node = SgAsmDwarfUpcSharedType;
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
3460template <> struct describe_node_t<SgAsmDwarfUpcStrictType> {
3461 using node = SgAsmDwarfUpcStrictType;
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
3472template <> struct describe_node_t<SgAsmDwarfVariable> {
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
3484template <> struct describe_node_t<SgAsmDwarfVariant> {
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
3496template <> struct describe_node_t<SgAsmDwarfVariantPart> {
3497 using node = SgAsmDwarfVariantPart;
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
3508template <> struct describe_node_t<SgAsmDwarfVolatileType> {
3509 using node = SgAsmDwarfVolatileType;
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
3520template <> struct describe_node_t<SgAsmDwarfWithStmt> {
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> {
3533 using parent = SgAsmElfDynamicEntry;
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> {
3544 using parent = SgAsmElfDynamicEntry;
3545 using field_type = Rose::BinaryAnalysis::RelativeVirtualAddress;
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> {
3555 using parent = SgAsmElfDynamicEntry;
3556 using field_type = SgAsmGenericString*;
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> {
3566 using parent = SgAsmElfDynamicEntry;
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> {
3589 using parent = SgAsmElfDynamicEntryList;
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};
3599template <> struct describe_node_t<SgAsmElfDynamicEntryList> {
3600 using node = SgAsmElfDynamicEntryList;
3601 using base = SgAsmExecutableFileFormat;
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<>;
3606 using fields_t = mp::List<describe_field_t<SgAsmElfDynamicEntryList,SgAsmElfDynamicEntryPtrList,&SgAsmElfDynamicEntryList::p_entries>>;
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> {
3612 using parent = SgAsmElfDynamicSection;
3613 using field_type = SgAsmElfDynamicEntryList*;
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};
3622template <> struct describe_node_t<SgAsmElfDynamicSection> {
3623 using node = SgAsmElfDynamicSection;
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<>;
3629 using fields_t = mp::List<describe_field_t<SgAsmElfDynamicSection,SgAsmElfDynamicEntryList*,&SgAsmElfDynamicSection::p_entries>>;
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> {
3635 using parent = SgAsmElfEHFrameEntryCI;
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> {
3646 using parent = SgAsmElfEHFrameEntryCI;
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> {
3657 using parent = SgAsmElfEHFrameEntryCI;
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> {
3668 using parent = SgAsmElfEHFrameEntryCI;
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> {
3679 using parent = SgAsmElfEHFrameEntryCI;
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> {
3690 using parent = SgAsmElfEHFrameEntryCI;
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> {
3701 using parent = SgAsmElfEHFrameEntryCI;
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> {
3712 using parent = SgAsmElfEHFrameEntryCI;
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> {
3723 using parent = SgAsmElfEHFrameEntryCI;
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> {
3734 using parent = SgAsmElfEHFrameEntryCI;
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> {
3745 using parent = SgAsmElfEHFrameEntryCI;
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> {
3756 using parent = SgAsmElfEHFrameEntryCI;
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> {
3767 using parent = SgAsmElfEHFrameEntryCI;
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> {
3778 using parent = SgAsmElfEHFrameEntryCI;
3779 using field_type = SgAsmElfEHFrameEntryFDList*;
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};
3788template <> struct describe_node_t<SgAsmElfEHFrameEntryCI> {
3789 using node = SgAsmElfEHFrameEntryCI;
3790 using base = SgAsmExecutableFileFormat;
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<>;
3795 using fields_t = mp::List<describe_field_t<SgAsmElfEHFrameEntryCI,int,&SgAsmElfEHFrameEntryCI::p_version>, describe_field_t<SgAsmElfEHFrameEntryCI,std::string,&SgAsmElfEHFrameEntryCI::p_augmentation_string>, describe_field_t<SgAsmElfEHFrameEntryCI,uint64_t,&SgAsmElfEHFrameEntryCI::p_eh_data>, describe_field_t<SgAsmElfEHFrameEntryCI,uint64_t,&SgAsmElfEHFrameEntryCI::p_code_alignment_factor>, describe_field_t<SgAsmElfEHFrameEntryCI,int64_t,&SgAsmElfEHFrameEntryCI::p_data_alignment_factor>, describe_field_t<SgAsmElfEHFrameEntryCI,uint64_t,&SgAsmElfEHFrameEntryCI::p_augmentation_data_length>, describe_field_t<SgAsmElfEHFrameEntryCI,int,&SgAsmElfEHFrameEntryCI::p_lsda_encoding>, describe_field_t<SgAsmElfEHFrameEntryCI,int,&SgAsmElfEHFrameEntryCI::p_prh_encoding>, describe_field_t<SgAsmElfEHFrameEntryCI,unsigned,&SgAsmElfEHFrameEntryCI::p_prh_arg>, describe_field_t<SgAsmElfEHFrameEntryCI,Rose::BinaryAnalysis::Address,&SgAsmElfEHFrameEntryCI::p_prh_addr>, describe_field_t<SgAsmElfEHFrameEntryCI,int,&SgAsmElfEHFrameEntryCI::p_addr_encoding>, describe_field_t<SgAsmElfEHFrameEntryCI,bool,&SgAsmElfEHFrameEntryCI::p_sig_frame>, describe_field_t<SgAsmElfEHFrameEntryCI,SgUnsignedCharList,&SgAsmElfEHFrameEntryCI::p_instructions>, describe_field_t<SgAsmElfEHFrameEntryCI,SgAsmElfEHFrameEntryFDList*,&SgAsmElfEHFrameEntryCI::p_fd_entries>>;
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> {
3801 using parent = SgAsmElfEHFrameEntryCIList;
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};
3811template <> struct describe_node_t<SgAsmElfEHFrameEntryCIList> {
3812 using node = SgAsmElfEHFrameEntryCIList;
3813 using base = SgAsmExecutableFileFormat;
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<>;
3818 using fields_t = mp::List<describe_field_t<SgAsmElfEHFrameEntryCIList,SgAsmElfEHFrameEntryCIPtrList,&SgAsmElfEHFrameEntryCIList::p_entries>>;
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> {
3824 using parent = SgAsmElfEHFrameEntryFD;
3825 using field_type = Rose::BinaryAnalysis::RelativeVirtualAddress;
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> {
3835 using parent = SgAsmElfEHFrameEntryFD;
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> {
3846 using parent = SgAsmElfEHFrameEntryFD;
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> {
3857 using parent = SgAsmElfEHFrameEntryFD;
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> {
3880 using parent = SgAsmElfEHFrameEntryFDList;
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};
3890template <> struct describe_node_t<SgAsmElfEHFrameEntryFDList> {
3891 using node = SgAsmElfEHFrameEntryFDList;
3892 using base = SgAsmExecutableFileFormat;
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<>;
3897 using fields_t = mp::List<describe_field_t<SgAsmElfEHFrameEntryFDList,SgAsmElfEHFrameEntryFDPtrList,&SgAsmElfEHFrameEntryFDList::p_entries>>;
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> {
3903 using parent = SgAsmElfEHFrameSection;
3904 using field_type = SgAsmElfEHFrameEntryCIList*;
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};
3913template <> struct describe_node_t<SgAsmElfEHFrameSection> {
3914 using node = SgAsmElfEHFrameSection;
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<>;
3920 using fields_t = mp::List<describe_field_t<SgAsmElfEHFrameSection,SgAsmElfEHFrameEntryCIList*,&SgAsmElfEHFrameSection::p_ci_entries>>;
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;
4070 using field_type = SgAsmElfSectionTable*;
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;
4081 using field_type = SgAsmElfSegmentTable*;
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};
4090template <> struct describe_node_t<SgAsmElfFileHeader> {
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<>;
4097 using fields_t = mp::List<describe_field_t<SgAsmElfFileHeader,unsigned char,&SgAsmElfFileHeader::p_e_ident_file_class>, describe_field_t<SgAsmElfFileHeader,unsigned char,&SgAsmElfFileHeader::p_e_ident_data_encoding>, describe_field_t<SgAsmElfFileHeader,unsigned char,&SgAsmElfFileHeader::p_e_ident_file_version>, describe_field_t<SgAsmElfFileHeader,SgUnsignedCharList,&SgAsmElfFileHeader::p_e_ident_padding>, describe_field_t<SgAsmElfFileHeader,unsigned long,&SgAsmElfFileHeader::p_e_type>, describe_field_t<SgAsmElfFileHeader,unsigned long,&SgAsmElfFileHeader::p_e_machine>, describe_field_t<SgAsmElfFileHeader,unsigned long,&SgAsmElfFileHeader::p_e_flags>, describe_field_t<SgAsmElfFileHeader,unsigned long,&SgAsmElfFileHeader::p_e_ehsize>, describe_field_t<SgAsmElfFileHeader,unsigned long,&SgAsmElfFileHeader::p_phextrasz>, describe_field_t<SgAsmElfFileHeader,unsigned long,&SgAsmElfFileHeader::p_e_phnum>, describe_field_t<SgAsmElfFileHeader,unsigned long,&SgAsmElfFileHeader::p_shextrasz>, describe_field_t<SgAsmElfFileHeader,unsigned long,&SgAsmElfFileHeader::p_e_shnum>, describe_field_t<SgAsmElfFileHeader,unsigned long,&SgAsmElfFileHeader::p_e_shstrndx>, describe_field_t<SgAsmElfFileHeader,SgAsmElfSectionTable*,&SgAsmElfFileHeader::p_sectionTable>, describe_field_t<SgAsmElfFileHeader,SgAsmElfSegmentTable*,&SgAsmElfFileHeader::p_segmentTable>>;
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;
4115 using field_type = SgAsmGenericString*;
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};
4135template <> struct describe_node_t<SgAsmElfNoteEntry> {
4136 using node = SgAsmElfNoteEntry;
4137 using base = SgAsmExecutableFileFormat;
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<>;
4142 using fields_t = mp::List<describe_field_t<SgAsmElfNoteEntry,unsigned,&SgAsmElfNoteEntry::p_type>, describe_field_t<SgAsmElfNoteEntry,SgAsmGenericString*,&SgAsmElfNoteEntry::p_name>, describe_field_t<SgAsmElfNoteEntry,SgUnsignedCharList,&SgAsmElfNoteEntry::p_payload>>;
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> {
4148 using parent = SgAsmElfNoteEntryList;
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};
4158template <> struct describe_node_t<SgAsmElfNoteEntryList> {
4159 using node = SgAsmElfNoteEntryList;
4160 using base = SgAsmExecutableFileFormat;
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<>;
4165 using fields_t = mp::List<describe_field_t<SgAsmElfNoteEntryList,SgAsmElfNoteEntryPtrList,&SgAsmElfNoteEntryList::p_entries>>;
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> {
4171 using parent = SgAsmElfNoteSection;
4172 using field_type = SgAsmElfNoteEntryList*;
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};
4181template <> struct describe_node_t<SgAsmElfNoteSection> {
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<>;
4188 using fields_t = mp::List<describe_field_t<SgAsmElfNoteSection,SgAsmElfNoteEntryList*,&SgAsmElfNoteSection::p_entries>>;
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;
4228 using field_type = SgAsmElfRelocEntry::RelocType;
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> {
4261 using parent = SgAsmElfRelocEntryList;
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};
4271template <> struct describe_node_t<SgAsmElfRelocEntryList> {
4272 using node = SgAsmElfRelocEntryList;
4273 using base = SgAsmExecutableFileFormat;
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<>;
4278 using fields_t = mp::List<describe_field_t<SgAsmElfRelocEntryList,SgAsmElfRelocEntryPtrList,&SgAsmElfRelocEntryList::p_entries>>;
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> {
4284 using parent = SgAsmElfRelocSection;
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> {
4295 using parent = SgAsmElfRelocSection;
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> {
4306 using parent = SgAsmElfRelocSection;
4307 using field_type = SgAsmElfRelocEntryList*;
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};
4316template <> struct describe_node_t<SgAsmElfRelocSection> {
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<>;
4323 using fields_t = mp::List<describe_field_t<SgAsmElfRelocSection,bool,&SgAsmElfRelocSection::p_usesAddend>, describe_field_t<SgAsmElfRelocSection,SgAsmElfSection*,&SgAsmElfRelocSection::p_targetSection>, describe_field_t<SgAsmElfRelocSection,SgAsmElfRelocEntryList*,&SgAsmElfRelocSection::p_entries>>;
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;
4341 using field_type = SgAsmElfSectionTableEntry*;
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;
4352 using field_type = SgAsmElfSegmentTableEntry*;
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
4373template <> struct describe_node_t<SgAsmElfSectionTable> {
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> {
4386 using parent = SgAsmElfSectionTableEntry;
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> {
4397 using parent = SgAsmElfSectionTableEntry;
4398 using field_type = SgAsmElfSectionTableEntry::SectionType;
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> {
4408 using parent = SgAsmElfSectionTableEntry;
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> {
4419 using parent = SgAsmElfSectionTableEntry;
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> {
4430 using parent = SgAsmElfSectionTableEntry;
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> {
4441 using parent = SgAsmElfSectionTableEntry;
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> {
4452 using parent = SgAsmElfSectionTableEntry;
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> {
4463 using parent = SgAsmElfSectionTableEntry;
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> {
4474 using parent = SgAsmElfSectionTableEntry;
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> {
4485 using parent = SgAsmElfSectionTableEntry;
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> {
4496 using parent = SgAsmElfSectionTableEntry;
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};
4506template <> struct describe_node_t<SgAsmElfSectionTableEntry> {
4507 using node = SgAsmElfSectionTableEntry;
4508 using base = SgAsmExecutableFileFormat;
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<>;
4513 using fields_t = mp::List<describe_field_t<SgAsmElfSectionTableEntry,unsigned,&SgAsmElfSectionTableEntry::p_sh_name>, describe_field_t<SgAsmElfSectionTableEntry,SgAsmElfSectionTableEntry::SectionType,&SgAsmElfSectionTableEntry::p_sh_type>, describe_field_t<SgAsmElfSectionTableEntry,unsigned long,&SgAsmElfSectionTableEntry::p_sh_link>, describe_field_t<SgAsmElfSectionTableEntry,unsigned long,&SgAsmElfSectionTableEntry::p_sh_info>, describe_field_t<SgAsmElfSectionTableEntry,uint64_t,&SgAsmElfSectionTableEntry::p_sh_flags>, describe_field_t<SgAsmElfSectionTableEntry,Rose::BinaryAnalysis::Address,&SgAsmElfSectionTableEntry::p_sh_addr>, describe_field_t<SgAsmElfSectionTableEntry,Rose::BinaryAnalysis::Address,&SgAsmElfSectionTableEntry::p_sh_offset>, describe_field_t<SgAsmElfSectionTableEntry,Rose::BinaryAnalysis::Address,&SgAsmElfSectionTableEntry::p_sh_size>, describe_field_t<SgAsmElfSectionTableEntry,Rose::BinaryAnalysis::Address,&SgAsmElfSectionTableEntry::p_sh_addralign>, describe_field_t<SgAsmElfSectionTableEntry,Rose::BinaryAnalysis::Address,&SgAsmElfSectionTableEntry::p_sh_entsize>, describe_field_t<SgAsmElfSectionTableEntry,SgUnsignedCharList,&SgAsmElfSectionTableEntry::p_extra>>;
4514};
4515template <> struct node_from_variant_t<165> { using type = SgAsmElfSectionTableEntry; };
4516
4517// Class: AsmElfSegmentTable
4518template <> struct describe_node_t<SgAsmElfSegmentTable> {
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> {
4531 using parent = SgAsmElfSegmentTableEntry;
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> {
4542 using parent = SgAsmElfSegmentTableEntry;
4543 using field_type = SgAsmElfSegmentTableEntry::SegmentType;
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> {
4553 using parent = SgAsmElfSegmentTableEntry;
4554 using field_type = SgAsmElfSegmentTableEntry::SegmentFlags;
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> {
4564 using parent = SgAsmElfSegmentTableEntry;
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> {
4575 using parent = SgAsmElfSegmentTableEntry;
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> {
4586 using parent = SgAsmElfSegmentTableEntry;
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> {
4597 using parent = SgAsmElfSegmentTableEntry;
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> {
4608 using parent = SgAsmElfSegmentTableEntry;
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> {
4619 using parent = SgAsmElfSegmentTableEntry;
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> {
4630 using parent = SgAsmElfSegmentTableEntry;
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> {
4653 using parent = SgAsmElfSegmentTableEntryList;
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};
4663template <> struct describe_node_t<SgAsmElfSegmentTableEntryList> {
4664 using node = SgAsmElfSegmentTableEntryList;
4665 using base = SgAsmExecutableFileFormat;
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<>;
4670 using fields_t = mp::List<describe_field_t<SgAsmElfSegmentTableEntryList,SgAsmElfSegmentTableEntryPtrList,&SgAsmElfSegmentTableEntryList::p_entries>>;
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> {
4676 using parent = SgAsmElfStringSection;
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};
4686template <> struct describe_node_t<SgAsmElfStringSection> {
4687 using node = SgAsmElfStringSection;
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<>;
4693 using fields_t = mp::List<describe_field_t<SgAsmElfStringSection,SgAsmElfStrtab*,&SgAsmElfStringSection::p_strtab>>;
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};
4788template <> struct describe_node_t<SgAsmElfSymbolList> {
4789 using node = SgAsmElfSymbolList;
4790 using base = SgAsmExecutableFileFormat;
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<>;
4795 using fields_t = mp::List<describe_field_t<SgAsmElfSymbolList,SgAsmElfSymbolPtrList,&SgAsmElfSymbolList::p_symbols>>;
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> {
4801 using parent = SgAsmElfSymbolSection;
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> {
4812 using parent = SgAsmElfSymbolSection;
4813 using field_type = SgAsmElfSymbolList*;
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};
4822template <> struct describe_node_t<SgAsmElfSymbolSection> {
4823 using node = SgAsmElfSymbolSection;
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<>;
4829 using fields_t = mp::List<describe_field_t<SgAsmElfSymbolSection,bool,&SgAsmElfSymbolSection::p_isDynamic>, describe_field_t<SgAsmElfSymbolSection,SgAsmElfSymbolList*,&SgAsmElfSymbolSection::p_symbols>>;
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> {
4835 using parent = SgAsmElfSymverDefinedAux;
4836 using field_type = SgAsmGenericString*;
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};
4845template <> struct describe_node_t<SgAsmElfSymverDefinedAux> {
4846 using node = SgAsmElfSymverDefinedAux;
4847 using base = SgAsmExecutableFileFormat;
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<>;
4852 using fields_t = mp::List<describe_field_t<SgAsmElfSymverDefinedAux,SgAsmGenericString*,&SgAsmElfSymverDefinedAux::p_name>>;
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> {
4858 using parent = SgAsmElfSymverDefinedAuxList;
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};
4868template <> struct describe_node_t<SgAsmElfSymverDefinedAuxList> {
4869 using node = SgAsmElfSymverDefinedAuxList;
4870 using base = SgAsmExecutableFileFormat;
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<>;
4875 using fields_t = mp::List<describe_field_t<SgAsmElfSymverDefinedAuxList,SgAsmElfSymverDefinedAuxPtrList,&SgAsmElfSymverDefinedAuxList::p_entries>>;
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> {
4881 using parent = SgAsmElfSymverDefinedEntry;
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> {
4892 using parent = SgAsmElfSymverDefinedEntry;
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> {
4903 using parent = SgAsmElfSymverDefinedEntry;
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> {
4914 using parent = SgAsmElfSymverDefinedEntry;
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> {
4925 using parent = SgAsmElfSymverDefinedEntry;
4926 using field_type = SgAsmElfSymverDefinedAuxList*;
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> {
4948 using parent = SgAsmElfSymverDefinedEntryList;
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};
4958template <> struct describe_node_t<SgAsmElfSymverDefinedEntryList> {
4959 using node = SgAsmElfSymverDefinedEntryList;
4960 using base = SgAsmExecutableFileFormat;
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<>;
4965 using fields_t = mp::List<describe_field_t<SgAsmElfSymverDefinedEntryList,SgAsmElfSymverDefinedEntryPtrList,&SgAsmElfSymverDefinedEntryList::p_entries>>;
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> {
4971 using parent = SgAsmElfSymverDefinedSection;
4972 using field_type = SgAsmElfSymverDefinedEntryList*;
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};
4981template <> struct describe_node_t<SgAsmElfSymverDefinedSection> {
4982 using node = SgAsmElfSymverDefinedSection;
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<>;
4988 using fields_t = mp::List<describe_field_t<SgAsmElfSymverDefinedSection,SgAsmElfSymverDefinedEntryList*,&SgAsmElfSymverDefinedSection::p_entries>>;
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> {
4994 using parent = SgAsmElfSymverEntry;
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};
5004template <> struct describe_node_t<SgAsmElfSymverEntry> {
5005 using node = SgAsmElfSymverEntry;
5006 using base = SgAsmExecutableFileFormat;
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<>;
5011 using fields_t = mp::List<describe_field_t<SgAsmElfSymverEntry,size_t,&SgAsmElfSymverEntry::p_value>>;
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> {
5017 using parent = SgAsmElfSymverEntryList;
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};
5027template <> struct describe_node_t<SgAsmElfSymverEntryList> {
5028 using node = SgAsmElfSymverEntryList;
5029 using base = SgAsmExecutableFileFormat;
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<>;
5034 using fields_t = mp::List<describe_field_t<SgAsmElfSymverEntryList,SgAsmElfSymverEntryPtrList,&SgAsmElfSymverEntryList::p_entries>>;
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> {
5040 using parent = SgAsmElfSymverNeededAux;
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> {
5051 using parent = SgAsmElfSymverNeededAux;
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> {
5062 using parent = SgAsmElfSymverNeededAux;
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> {
5073 using parent = SgAsmElfSymverNeededAux;
5074 using field_type = SgAsmGenericString*;
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> {
5096 using parent = SgAsmElfSymverNeededAuxList;
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};
5106template <> struct describe_node_t<SgAsmElfSymverNeededAuxList> {
5107 using node = SgAsmElfSymverNeededAuxList;
5108 using base = SgAsmExecutableFileFormat;
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<>;
5113 using fields_t = mp::List<describe_field_t<SgAsmElfSymverNeededAuxList,SgAsmElfSymverNeededAuxPtrList,&SgAsmElfSymverNeededAuxList::p_entries>>;
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> {
5119 using parent = SgAsmElfSymverNeededEntry;
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> {
5130 using parent = SgAsmElfSymverNeededEntry;
5131 using field_type = SgAsmGenericString*;
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> {
5141 using parent = SgAsmElfSymverNeededEntry;
5142 using field_type = SgAsmElfSymverNeededAuxList*;
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> {
5164 using parent = SgAsmElfSymverNeededEntryList;
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};
5174template <> struct describe_node_t<SgAsmElfSymverNeededEntryList> {
5175 using node = SgAsmElfSymverNeededEntryList;
5176 using base = SgAsmExecutableFileFormat;
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<>;
5181 using fields_t = mp::List<describe_field_t<SgAsmElfSymverNeededEntryList,SgAsmElfSymverNeededEntryPtrList,&SgAsmElfSymverNeededEntryList::p_entries>>;
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> {
5187 using parent = SgAsmElfSymverNeededSection;
5188 using field_type = SgAsmElfSymverNeededEntryList*;
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};
5197template <> struct describe_node_t<SgAsmElfSymverNeededSection> {
5198 using node = SgAsmElfSymverNeededSection;
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<>;
5204 using fields_t = mp::List<describe_field_t<SgAsmElfSymverNeededSection,SgAsmElfSymverNeededEntryList*,&SgAsmElfSymverNeededSection::p_entries>>;
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> {
5210 using parent = SgAsmElfSymverSection;
5211 using field_type = SgAsmElfSymverEntryList*;
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};
5220template <> struct describe_node_t<SgAsmElfSymverSection> {
5221 using node = SgAsmElfSymverSection;
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<>;
5227 using fields_t = mp::List<describe_field_t<SgAsmElfSymverSection,SgAsmElfSymverEntryList*,&SgAsmElfSymverSection::p_entries>>;
5228};
5229template <> struct node_from_variant_t<186> { using type = SgAsmElfSymverSection; };
5230
5231// Class: AsmExecutableFileFormat
5232template <> struct describe_node_t<SgAsmExecutableFileFormat> {
5233 using node = SgAsmExecutableFileFormat;
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};
5238 using subclasses_t = mp::List<SgAsmCoffSymbolList, SgAsmDwarfInformation, SgAsmElfDynamicEntry, SgAsmElfDynamicEntryList, SgAsmElfEHFrameEntryCI, SgAsmElfEHFrameEntryCIList, SgAsmElfEHFrameEntryFD, SgAsmElfEHFrameEntryFDList, SgAsmElfNoteEntry, SgAsmElfNoteEntryList, SgAsmElfRelocEntry, SgAsmElfRelocEntryList, SgAsmElfSectionTableEntry, SgAsmElfSegmentTableEntry, SgAsmElfSegmentTableEntryList, SgAsmElfSymbolList, SgAsmElfSymverDefinedAux, SgAsmElfSymverDefinedAuxList, SgAsmElfSymverDefinedEntry, SgAsmElfSymverDefinedEntryList, SgAsmElfSymverEntry, SgAsmElfSymverEntryList, SgAsmElfSymverNeededAux, SgAsmElfSymverNeededAuxList, SgAsmElfSymverNeededEntry, SgAsmElfSymverNeededEntryList, SgAsmGenericDLL, SgAsmGenericDLLList, SgAsmGenericFile, SgAsmGenericFormat, SgAsmGenericHeaderList, SgAsmGenericSection, SgAsmGenericSectionList, SgAsmGenericString, SgAsmGenericStrtab, SgAsmGenericSymbol, SgAsmGenericSymbolList, SgAsmLEEntryPoint, SgAsmLEPageTableEntry, SgAsmLESectionTableEntry, SgAsmNEEntryPoint, SgAsmNERelocEntry, SgAsmNESectionTableEntry, SgAsmPEExportDirectory, SgAsmPEExportEntry, SgAsmPEExportEntryList, SgAsmPEImportDirectory, SgAsmPEImportDirectoryList, SgAsmPEImportItem, SgAsmPEImportItemList, SgAsmPERVASizePair, SgAsmPERVASizePairList, SgAsmPESectionTableEntry, SgAsmStringStorage>;
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};
5255template <> struct describe_node_t<SgAsmExprListExp> {
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<>;
5262 using fields_t = mp::List<describe_field_t<SgAsmExprListExp,SgAsmExpressionPtrList,&SgAsmExprListExp::p_expressions>>;
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> {
5302 using parent = SgAsmSynthesizedFieldDeclaration;
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> {
5313 using parent = SgAsmSynthesizedFieldDeclaration;
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};
5323template <> struct describe_node_t<SgAsmSynthesizedFieldDeclaration> {
5324 using node = SgAsmSynthesizedFieldDeclaration;
5325 using base = SgAsmSynthesizedDeclaration;
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<>;
5330 using fields_t = mp::List<describe_field_t<SgAsmSynthesizedFieldDeclaration,std::string,&SgAsmSynthesizedFieldDeclaration::p_name>, describe_field_t<SgAsmSynthesizedFieldDeclaration,uint64_t,&SgAsmSynthesizedFieldDeclaration::p_offset>>;
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
5424template <> struct describe_node_t<SgAsmFloatValueExpression> {
5425 using node = SgAsmFloatValueExpression;
5426 using base = SgAsmConstantExpression;
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;
5471 using field_type = SgAsmFunction::function_kind_enum;
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;
5482 using field_type = SgAsmFunction::MayReturn;
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;
5593 using field_type = SgAsmGenericString*;
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};
5613template <> struct describe_node_t<SgAsmGenericDLL> {
5614 using node = SgAsmGenericDLL;
5615 using base = SgAsmExecutableFileFormat;
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<>;
5620 using fields_t = mp::List<describe_field_t<SgAsmGenericDLL,SgAsmGenericString*,&SgAsmGenericDLL::p_name>, describe_field_t<SgAsmGenericDLL,SgStringList,&SgAsmGenericDLL::p_symbols>>;
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> {
5626 using parent = SgAsmGenericDLLList;
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};
5636template <> struct describe_node_t<SgAsmGenericDLLList> {
5637 using node = SgAsmGenericDLLList;
5638 using base = SgAsmExecutableFileFormat;
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<>;
5643 using fields_t = mp::List<describe_field_t<SgAsmGenericDLLList,SgAsmGenericDLLPtrList,&SgAsmGenericDLLList::p_dlls>>;
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;
5650 using field_type = SgAsmDwarfCompilationUnitList*;
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;
5694 using field_type = SgFileContentList;
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;
5705 using field_type = SgAsmGenericHeaderList*;
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;
5716 using field_type = SgAsmGenericSectionList*;
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;
5749 using field_type = Rose::BinaryAnalysis::AddressIntervalSet;
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> {
5782 using parent = SgAsmGenericFileList;
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};
5792template <> struct describe_node_t<SgAsmGenericFileList> {
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<>;
5799 using fields_t = mp::List<describe_field_t<SgAsmGenericFileList,SgAsmGenericFilePtrList,&SgAsmGenericFileList::p_files>>;
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;
5806 using field_type = SgAsmGenericFormat::ExecFamily;
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;
5817 using field_type = SgAsmGenericFormat::ExecPurpose;
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};
5826template <> struct describe_field_t<SgAsmGenericFormat,Rose::BinaryAnalysis::ByteOrder::Endianness,&SgAsmGenericFormat::p_sex> {
5827 using parent = SgAsmGenericFormat;
5828 using field_type = Rose::BinaryAnalysis::ByteOrder::Endianness;
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;
5861 using field_type = SgAsmGenericFormat::ExecABI;
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;
5906 using field_type = SgAsmGenericFormat*;
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;
5928 using field_type = SgAsmGenericFormat::InsSetArchitecture;
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;
5961 using field_type = SgAsmGenericDLLList*;
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;
5972 using field_type = SgAsmGenericSectionList*;
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> {
5994 using parent = SgAsmGenericHeaderList;
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};
6004template <> struct describe_node_t<SgAsmGenericHeaderList> {
6005 using node = SgAsmGenericHeaderList;
6006 using base = SgAsmExecutableFileFormat;
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<>;
6011 using fields_t = mp::List<describe_field_t<SgAsmGenericHeaderList,SgAsmGenericHeaderPtrList,&SgAsmGenericHeaderList::p_headers>>;
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> {
6017 using parent = SgAsmGenericSection;
6018 using field_type = SgAsmGenericFile*;
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> {
6028 using parent = SgAsmGenericSection;
6029 using field_type = SgAsmGenericHeader*;
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> {
6039 using parent = SgAsmGenericSection;
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> {
6050 using parent = SgAsmGenericSection;
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> {
6061 using parent = SgAsmGenericSection;
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> {
6072 using parent = SgAsmGenericSection;
6073 using field_type = SgFileContentList;
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> {
6083 using parent = SgAsmGenericSection;
6084 using field_type = SgAsmGenericSection::SectionPurpose;
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> {
6094 using parent = SgAsmGenericSection;
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> {
6105 using parent = SgAsmGenericSection;
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> {
6116 using parent = SgAsmGenericSection;
6117 using field_type = SgAsmGenericString*;
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> {
6127 using parent = SgAsmGenericSection;
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> {
6138 using parent = SgAsmGenericSection;
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> {
6149 using parent = SgAsmGenericSection;
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> {
6160 using parent = SgAsmGenericSection;
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> {
6171 using parent = SgAsmGenericSection;
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> {
6182 using parent = SgAsmGenericSection;
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> {
6193 using parent = SgAsmGenericSection;
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> {
6204 using parent = SgAsmGenericSection;
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> {
6215 using parent = SgAsmGenericSection;
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};
6225template <> struct describe_node_t<SgAsmGenericSection> {
6226 using node = SgAsmGenericSection;
6227 using base = SgAsmExecutableFileFormat;
6228 static constexpr char const * const name{"AsmGenericSection"};
6229 static constexpr unsigned long variant{201};
6230 static constexpr bool concrete{true};
6231 using subclasses_t = mp::List<SgAsmCliHeader, SgAsmCoffSymbolTable, SgAsmDOSExtendedHeader, SgAsmElfSection, SgAsmElfSectionTable, SgAsmElfSegmentTable, SgAsmGenericHeader, SgAsmJvmAttributeTable, SgAsmJvmConstantPool, SgAsmJvmFieldTable, SgAsmJvmMethodTable, SgAsmLEEntryTable, SgAsmLENameTable, SgAsmLEPageTable, SgAsmLERelocTable, SgAsmLESection, SgAsmLESectionTable, SgAsmNEEntryTable, SgAsmNEModuleTable, SgAsmNENameTable, SgAsmNERelocTable, SgAsmNESection, SgAsmNESectionTable, SgAsmNEStringTable, SgAsmPESection, SgAsmPESectionTable>;
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> {
6238 using parent = SgAsmGenericSectionList;
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};
6248template <> struct describe_node_t<SgAsmGenericSectionList> {
6249 using node = SgAsmGenericSectionList;
6250 using base = SgAsmExecutableFileFormat;
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<>;
6255 using fields_t = mp::List<describe_field_t<SgAsmGenericSectionList,SgAsmGenericSectionPtrList,&SgAsmGenericSectionList::p_sections>>;
6256};
6257template <> struct node_from_variant_t<202> { using type = SgAsmGenericSectionList; };
6258
6259// Class: AsmGenericString
6260template <> struct describe_node_t<SgAsmGenericString> {
6261 using node = SgAsmGenericString;
6262 using base = SgAsmExecutableFileFormat;
6263 static constexpr char const * const name{"AsmGenericString"};
6264 static constexpr unsigned long variant{203};
6265 static constexpr bool concrete{false};
6266 using subclasses_t = mp::List<SgAsmBasicString, SgAsmStoredString>;
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;
6274 using field_type = SgAsmGenericSection*;
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;
6296 using field_type = Rose::BinaryAnalysis::AddressIntervalSet;
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;
6307 using field_type = SgAsmStringStorage*;
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;
6341 using field_type = SgAsmGenericSymbol::SymbolDefState;
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;
6352 using field_type = SgAsmGenericSymbol::SymbolBinding;
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;
6363 using field_type = SgAsmGenericSymbol::SymbolType;
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;
6396 using field_type = SgAsmGenericSection*;
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;
6407 using field_type = SgAsmGenericString*;
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> {
6429 using parent = SgAsmGenericSymbolList;
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};
6439template <> struct describe_node_t<SgAsmGenericSymbolList> {
6440 using node = SgAsmGenericSymbolList;
6441 using base = SgAsmExecutableFileFormat;
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<>;
6446 using fields_t = mp::List<describe_field_t<SgAsmGenericSymbolList,SgAsmGenericSymbolPtrList,&SgAsmGenericSymbolList::p_symbols>>;
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> {
6452 using parent = SgAsmIndirectRegisterExpression;
6453 using field_type = Rose::BinaryAnalysis::RegisterDescriptor;
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> {
6463 using parent = SgAsmIndirectRegisterExpression;
6464 using field_type = Rose::BinaryAnalysis::RegisterDescriptor;
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> {
6474 using parent = SgAsmIndirectRegisterExpression;
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> {
6485 using parent = SgAsmIndirectRegisterExpression;
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;
6531 using field_type = SgAsmOperandList*;
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;
6542 using field_type = 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;
6553 using field_type = SgAsmExprListExp*;
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> {
6575 using parent = SgAsmIntegerValueExpression;
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};
6585template <> struct describe_node_t<SgAsmIntegerValueExpression> {
6586 using node = SgAsmIntegerValueExpression;
6587 using base = SgAsmConstantExpression;
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<>;
6592 using fields_t = mp::List<describe_field_t<SgAsmIntegerValueExpression,SgNode*,&SgAsmIntegerValueExpression::p_baseNode>>;
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};
6608template <> struct describe_node_t<SgAsmIntegerType> {
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<>;
6615 using fields_t = mp::List<describe_field_t<SgAsmIntegerType,bool,&SgAsmIntegerType::p_isSigned>>;
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> {
6621 using parent = SgAsmInterpretation;
6622 using field_type = SgAsmGenericHeaderList*;
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> {
6632 using parent = SgAsmInterpretation;
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> {
6643 using parent = SgAsmInterpretation;
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> {
6654 using parent = SgAsmInterpretation;
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> {
6677 using parent = SgAsmInterpretationList;
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};
6687template <> struct describe_node_t<SgAsmInterpretationList> {
6688 using node = SgAsmInterpretationList;
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<>;
6694 using fields_t = mp::List<describe_field_t<SgAsmInterpretationList,SgAsmInterpretationPtrList,&SgAsmInterpretationList::p_interpretations>>;
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> {
6734 using parent = SgAsmJvmCodeAttribute;
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> {
6745 using parent = SgAsmJvmCodeAttribute;
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> {
6756 using parent = SgAsmJvmCodeAttribute;
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> {
6767 using parent = SgAsmJvmCodeAttribute;
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> {
6778 using parent = SgAsmJvmCodeAttribute;
6779 using field_type = SgAsmJvmExceptionTable*;
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> {
6789 using parent = SgAsmJvmCodeAttribute;
6790 using field_type = SgAsmJvmAttributeTable*;
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> {
6800 using parent = SgAsmJvmCodeAttribute;
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;
6857 using field_type = SgAsmJvmAttributeTable*;
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;
6868 using field_type = SgAsmInstructionList*;
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> {
6890 using parent = SgAsmJvmConstantPool;
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};
6900template <> struct describe_node_t<SgAsmJvmConstantPool> {
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<>;
6907 using fields_t = mp::List<describe_field_t<SgAsmJvmConstantPool,SgAsmJvmConstantPoolEntryPtrList,&SgAsmJvmConstantPool::p_entries>>;
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> {
6913 using parent = SgAsmJvmConstantPoolEntry;
6914 using field_type = SgAsmJvmConstantPoolEntry::Kind;
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> {
6924 using parent = SgAsmJvmConstantPoolEntry;
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> {
6935 using parent = SgAsmJvmConstantPoolEntry;
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> {
6946 using parent = SgAsmJvmConstantPoolEntry;
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> {
6957 using parent = SgAsmJvmConstantPoolEntry;
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> {
6968 using parent = SgAsmJvmConstantPoolEntry;
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> {
6979 using parent = SgAsmJvmConstantPoolEntry;
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> {
6990 using parent = SgAsmJvmConstantPoolEntry;
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> {
7001 using parent = SgAsmJvmConstantPoolEntry;
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> {
7012 using parent = SgAsmJvmConstantPoolEntry;
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> {
7023 using parent = SgAsmJvmConstantPoolEntry;
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> {
7034 using parent = SgAsmJvmConstantPoolEntry;
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> {
7045 using parent = SgAsmJvmConstantPoolEntry;
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> {
7056 using parent = SgAsmJvmConstantPoolEntry;
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};
7066template <> struct describe_node_t<SgAsmJvmConstantPoolEntry> {
7067 using node = SgAsmJvmConstantPoolEntry;
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<>;
7073 using fields_t = mp::List<describe_field_t<SgAsmJvmConstantPoolEntry,SgAsmJvmConstantPoolEntry::Kind,&SgAsmJvmConstantPoolEntry::p_tag>, describe_field_t<SgAsmJvmConstantPoolEntry,uint32_t,&SgAsmJvmConstantPoolEntry::p_bytes>, describe_field_t<SgAsmJvmConstantPoolEntry,uint32_t,&SgAsmJvmConstantPoolEntry::p_hi_bytes>, describe_field_t<SgAsmJvmConstantPoolEntry,uint32_t,&SgAsmJvmConstantPoolEntry::p_low_bytes>, describe_field_t<SgAsmJvmConstantPoolEntry,uint16_t,&SgAsmJvmConstantPoolEntry::p_bootstrap_method_attr_index>, describe_field_t<SgAsmJvmConstantPoolEntry,uint16_t,&SgAsmJvmConstantPoolEntry::p_class_index>, describe_field_t<SgAsmJvmConstantPoolEntry,uint16_t,&SgAsmJvmConstantPoolEntry::p_descriptor_index>, describe_field_t<SgAsmJvmConstantPoolEntry,uint16_t,&SgAsmJvmConstantPoolEntry::p_name_index>, describe_field_t<SgAsmJvmConstantPoolEntry,uint16_t,&SgAsmJvmConstantPoolEntry::p_name_and_type_index>, describe_field_t<SgAsmJvmConstantPoolEntry,uint16_t,&SgAsmJvmConstantPoolEntry::p_reference_index>, describe_field_t<SgAsmJvmConstantPoolEntry,uint8_t,&SgAsmJvmConstantPoolEntry::p_reference_kind>, describe_field_t<SgAsmJvmConstantPoolEntry,uint16_t,&SgAsmJvmConstantPoolEntry::p_string_index>, describe_field_t<SgAsmJvmConstantPoolEntry,uint16_t,&SgAsmJvmConstantPoolEntry::p_length>, describe_field_t<SgAsmJvmConstantPoolEntry,char*,&SgAsmJvmConstantPoolEntry::p_utf8_bytes>>;
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> {
7079 using parent = SgAsmJvmConstantValue;
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};
7089template <> struct describe_node_t<SgAsmJvmConstantValue> {
7090 using node = SgAsmJvmConstantValue;
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<>;
7096 using fields_t = mp::List<describe_field_t<SgAsmJvmConstantValue,uint16_t,&SgAsmJvmConstantValue::p_constantvalue_index>>;
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> {
7102 using parent = SgAsmJvmInstruction;
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};
7112template <> struct describe_node_t<SgAsmJvmInstruction> {
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<>;
7119 using fields_t = mp::List<describe_field_t<SgAsmJvmInstruction,Rose::BinaryAnalysis::JvmInstructionKind,&SgAsmJvmInstruction::p_kind>>;
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;
7181 using field_type = SgAsmJvmConstantPool*;
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;
7203 using field_type = SgAsmJvmFieldTable*;
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;
7214 using field_type = SgAsmJvmMethodTable*;
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;
7225 using field_type = SgAsmJvmAttributeTable*;
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};
7269template <> struct describe_node_t<SgAsmJvmSignature> {
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<>;
7276 using fields_t = mp::List<describe_field_t<SgAsmJvmSignature,uint16_t,&SgAsmJvmSignature::p_signature_index>>;
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};
7292template <> struct describe_node_t<SgAsmJvmSourceFile> {
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<>;
7299 using fields_t = mp::List<describe_field_t<SgAsmJvmSourceFile,uint16_t,&SgAsmJvmSourceFile::p_sourcefile_index>>;
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};
7404template <> struct describe_node_t<SgAsmLEEntryTable> {
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<>;
7411 using fields_t = mp::List<describe_field_t<SgAsmLEEntryTable,SgSizeTList,&SgAsmLEEntryTable::p_bundle_sizes>, describe_field_t<SgAsmLEEntryTable,SgAsmLEEntryPointPtrList,&SgAsmLEEntryTable::p_entries>>;
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;
7924 using field_type = SgAsmDOSExtendedHeader*;
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;
7935 using field_type = SgAsmLESectionTable*;
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;
7946 using field_type = SgAsmLEPageTable*;
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;
7957 using field_type = SgAsmLENameTable*;
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;
7968 using field_type = SgAsmLENameTable*;
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;
7979 using field_type = SgAsmLEEntryTable*;
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;
7990 using field_type = SgAsmLERelocTable*;
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};
7999template <> struct describe_node_t<SgAsmLEFileHeader> {
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};
8033template <> struct describe_node_t<SgAsmLENameTable> {
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<>;
8040 using fields_t = mp::List<describe_field_t<SgAsmLENameTable,SgStringList,&SgAsmLENameTable::p_names>, describe_field_t<SgAsmLENameTable,SgUnsignedList,&SgAsmLENameTable::p_ordinals>>;
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};
8056template <> struct describe_node_t<SgAsmLEPageTable> {
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<>;
8063 using fields_t = mp::List<describe_field_t<SgAsmLEPageTable,SgAsmLEPageTableEntryPtrList,&SgAsmLEPageTable::p_entries>>;
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> {
8069 using parent = SgAsmLEPageTableEntry;
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> {
8080 using parent = SgAsmLEPageTableEntry;
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};
8090template <> struct describe_node_t<SgAsmLEPageTableEntry> {
8091 using node = SgAsmLEPageTableEntry;
8092 using base = SgAsmExecutableFileFormat;
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<>;
8097 using fields_t = mp::List<describe_field_t<SgAsmLEPageTableEntry,unsigned,&SgAsmLEPageTableEntry::p_pageno>, describe_field_t<SgAsmLEPageTableEntry,unsigned,&SgAsmLEPageTableEntry::p_flags>>;
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};
8113template <> struct describe_node_t<SgAsmLERelocTable> {
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<>;
8120 using fields_t = mp::List<describe_field_t<SgAsmLERelocTable,SgAsmLERelocEntryPtrList,&SgAsmLERelocTable::p_entries>>;
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;
8127 using field_type = SgAsmLESectionTableEntry*;
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<>;
8143 using fields_t = mp::List<describe_field_t<SgAsmLESection,SgAsmLESectionTableEntry*,&SgAsmLESection::p_sectionTableEntry>>;
8144};
8145template <> struct node_from_variant_t<231> { using type = SgAsmLESection; };
8146
8147// Class: AsmLESectionTable
8148template <> struct describe_node_t<SgAsmLESectionTable> {
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> {
8161 using parent = SgAsmLESectionTableEntry;
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> {
8172 using parent = SgAsmLESectionTableEntry;
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> {
8183 using parent = SgAsmLESectionTableEntry;
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> {
8194 using parent = SgAsmLESectionTableEntry;
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> {
8205 using parent = SgAsmLESectionTableEntry;
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> {
8216 using parent = SgAsmLESectionTableEntry;
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> {
8239 using parent = SgAsmM68kInstruction;
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> {
8250 using parent = SgAsmM68kInstruction;
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};
8260template <> struct describe_node_t<SgAsmM68kInstruction> {
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<>;
8267 using fields_t = mp::List<describe_field_t<SgAsmM68kInstruction,Rose::BinaryAnalysis::M68kInstructionKind,&SgAsmM68kInstruction::p_kind>, describe_field_t<SgAsmM68kInstruction,Rose::BinaryAnalysis::M68kDataFormat,&SgAsmM68kInstruction::p_dataFormat>>;
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> {
8273 using parent = SgAsmMemoryReferenceExpression;
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> {
8284 using parent = SgAsmMemoryReferenceExpression;
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};
8294template <> struct describe_node_t<SgAsmMemoryReferenceExpression> {
8295 using node = SgAsmMemoryReferenceExpression;
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<>;
8301 using fields_t = mp::List<describe_field_t<SgAsmMemoryReferenceExpression,SgAsmExpression*,&SgAsmMemoryReferenceExpression::p_address>, describe_field_t<SgAsmMemoryReferenceExpression,SgAsmExpression*,&SgAsmMemoryReferenceExpression::p_segment>>;
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> {
8307 using parent = SgAsmMipsInstruction;
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};
8317template <> struct describe_node_t<SgAsmMipsInstruction> {
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<>;
8324 using fields_t = mp::List<describe_field_t<SgAsmMipsInstruction,Rose::BinaryAnalysis::MipsInstructionKind,&SgAsmMipsInstruction::p_kind>>;
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};
8407template <> struct describe_node_t<SgAsmNEEntryTable> {
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<>;
8414 using fields_t = mp::List<describe_field_t<SgAsmNEEntryTable,SgSizeTList,&SgAsmNEEntryTable::p_bundle_sizes>, describe_field_t<SgAsmNEEntryTable,SgAsmNEEntryPointPtrList,&SgAsmNEEntryTable::p_entries>>;
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;
8740 using field_type = SgAsmDOSExtendedHeader*;
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;
8751 using field_type = SgAsmNESectionTable*;
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;
8762 using field_type = SgAsmNENameTable*;
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;
8773 using field_type = SgAsmNENameTable*;
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;
8784 using field_type = SgAsmNEModuleTable*;
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;
8795 using field_type = SgAsmNEEntryTable*;
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};
8804template <> struct describe_node_t<SgAsmNEFileHeader> {
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;
8818 using field_type = SgAsmNEStringTable*;
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};
8849template <> struct describe_node_t<SgAsmNEModuleTable> {
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<>;
8856 using fields_t = mp::List<describe_field_t<SgAsmNEModuleTable,SgAsmNEStringTable*,&SgAsmNEModuleTable::p_strtab>, describe_field_t<SgAsmNEModuleTable,SgAddressList,&SgAsmNEModuleTable::p_nameOffsets>, describe_field_t<SgAsmNEModuleTable,SgStringList,&SgAsmNEModuleTable::p_names>>;
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};
8883template <> struct describe_node_t<SgAsmNENameTable> {
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<>;
8890 using fields_t = mp::List<describe_field_t<SgAsmNENameTable,SgStringList,&SgAsmNENameTable::p_names>, describe_field_t<SgAsmNENameTable,SgUnsignedList,&SgAsmNENameTable::p_ordinals>>;
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;
8952 using field_type = SgAsmNERelocEntry::iref_type;
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;
8963 using field_type = SgAsmNERelocEntry::iord_type;
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;
8974 using field_type = SgAsmNERelocEntry::iname_type;
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;
8985 using field_type = SgAsmNERelocEntry::osfixup_type;
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};
9017template <> struct describe_node_t<SgAsmNERelocTable> {
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<>;
9024 using fields_t = mp::List<describe_field_t<SgAsmNERelocTable,SgAsmNERelocEntryPtrList,&SgAsmNERelocTable::p_entries>>;
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;
9031 using field_type = SgAsmNESectionTableEntry*;
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;
9042 using field_type = SgAsmNERelocTable*;
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<>;
9058 using fields_t = mp::List<describe_field_t<SgAsmNESection,SgAsmNESectionTableEntry*,&SgAsmNESection::p_sectionTableEntry>, describe_field_t<SgAsmNESection,SgAsmNERelocTable*,&SgAsmNESection::p_relocationTable>>;
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> {
9064 using parent = SgAsmNESectionTable;
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> {
9075 using parent = SgAsmNESectionTable;
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> {
9086 using parent = SgAsmNESectionTable;
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> {
9097 using parent = SgAsmNESectionTable;
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> {
9120 using parent = SgAsmNESectionTableEntry;
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> {
9131 using parent = SgAsmNESectionTableEntry;
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> {
9142 using parent = SgAsmNESectionTableEntry;
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> {
9153 using parent = SgAsmNESectionTableEntry;
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
9175template <> struct describe_node_t<SgAsmNEStringTable> {
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};
9193 using subclasses_t = mp::List<SgAsmCilNode, SgAsmExecutableFileFormat, SgAsmExpression, SgAsmGenericFileList, SgAsmInstructionList, SgAsmInterpretation, SgAsmInterpretationList, SgAsmJvmNode, SgAsmOperandList, SgAsmStatement, SgAsmType>;
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;
9201 using field_type = SgAsmOp::asm_operand_constraint_enum;
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;
9212 using field_type = SgAsmOp::asm_operand_modifier_enum;
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};
9299template <> struct describe_node_t<SgAsmOperandList> {
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<>;
9306 using fields_t = mp::List<describe_field_t<SgAsmOperandList,SgAsmExpressionPtrList,&SgAsmOperandList::p_operands>>;
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> {
9312 using parent = SgAsmPEExportDirectory;
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> {
9323 using parent = SgAsmPEExportDirectory;
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> {
9334 using parent = SgAsmPEExportDirectory;
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> {
9345 using parent = SgAsmPEExportDirectory;
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> {
9356 using parent = SgAsmPEExportDirectory;
9357 using field_type = Rose::BinaryAnalysis::RelativeVirtualAddress;
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> {
9367 using parent = SgAsmPEExportDirectory;
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> {
9378 using parent = SgAsmPEExportDirectory;
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> {
9389 using parent = SgAsmPEExportDirectory;
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> {
9400 using parent = SgAsmPEExportDirectory;
9401 using field_type = Rose::BinaryAnalysis::RelativeVirtualAddress;
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> {
9411 using parent = SgAsmPEExportDirectory;
9412 using field_type = Rose::BinaryAnalysis::RelativeVirtualAddress;
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> {
9422 using parent = SgAsmPEExportDirectory;
9423 using field_type = Rose::BinaryAnalysis::RelativeVirtualAddress;
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> {
9433 using parent = SgAsmPEExportDirectory;
9434 using field_type = SgAsmGenericString*;
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};
9443template <> struct describe_node_t<SgAsmPEExportDirectory> {
9444 using node = SgAsmPEExportDirectory;
9445 using base = SgAsmExecutableFileFormat;
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<>;
9450 using fields_t = mp::List<describe_field_t<SgAsmPEExportDirectory,unsigned,&SgAsmPEExportDirectory::p_res1>, describe_field_t<SgAsmPEExportDirectory,time_t,&SgAsmPEExportDirectory::p_timestamp>, describe_field_t<SgAsmPEExportDirectory,unsigned,&SgAsmPEExportDirectory::p_vmajor>, describe_field_t<SgAsmPEExportDirectory,unsigned,&SgAsmPEExportDirectory::p_vminor>, describe_field_t<SgAsmPEExportDirectory,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmPEExportDirectory::p_name_rva>, describe_field_t<SgAsmPEExportDirectory,unsigned,&SgAsmPEExportDirectory::p_ord_base>, describe_field_t<SgAsmPEExportDirectory,size_t,&SgAsmPEExportDirectory::p_expaddr_n>, describe_field_t<SgAsmPEExportDirectory,size_t,&SgAsmPEExportDirectory::p_nameptr_n>, describe_field_t<SgAsmPEExportDirectory,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmPEExportDirectory::p_expaddr_rva>, describe_field_t<SgAsmPEExportDirectory,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmPEExportDirectory::p_nameptr_rva>, describe_field_t<SgAsmPEExportDirectory,Rose::BinaryAnalysis::RelativeVirtualAddress,&SgAsmPEExportDirectory::p_ordinals_rva>, describe_field_t<SgAsmPEExportDirectory,SgAsmGenericString*,&SgAsmPEExportDirectory::p_name>>;
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;
9457 using field_type = SgAsmGenericString*;
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;
9479 using field_type = Rose::BinaryAnalysis::RelativeVirtualAddress;
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;
9490 using field_type = SgAsmGenericString*;
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> {
9512 using parent = SgAsmPEExportEntryList;
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};
9522template <> struct describe_node_t<SgAsmPEExportEntryList> {
9523 using node = SgAsmPEExportEntryList;
9524 using base = SgAsmExecutableFileFormat;
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<>;
9529 using fields_t = mp::List<describe_field_t<SgAsmPEExportEntryList,SgAsmPEExportEntryPtrList,&SgAsmPEExportEntryList::p_exports>>;
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> {
9535 using parent = SgAsmPEExportSection;
9536 using field_type = SgAsmPEExportDirectory*;
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> {
9546 using parent = SgAsmPEExportSection;
9547 using field_type = SgAsmPEExportEntryList*;
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};
9556template <> struct describe_node_t<SgAsmPEExportSection> {
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<>;
9563 using fields_t = mp::List<describe_field_t<SgAsmPEExportSection,SgAsmPEExportDirectory*,&SgAsmPEExportSection::p_exportDirectory>, describe_field_t<SgAsmPEExportSection,SgAsmPEExportEntryList*,&SgAsmPEExportSection::p_exports>>;
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;
9713 using field_type = Rose::BinaryAnalysis::RelativeVirtualAddress;
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;
9724 using field_type = Rose::BinaryAnalysis::RelativeVirtualAddress;
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;
9955 using field_type = SgAsmPERVASizePairList*;
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;
9966 using field_type = SgAsmPESectionTable*;
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;
9977 using field_type = SgAsmCoffSymbolTable*;
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};
9986template <> struct describe_node_t<SgAsmPEFileHeader> {
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> {
9999 using parent = SgAsmPEImportDirectory;
10000 using field_type = SgAsmGenericString*;
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> {
10010 using parent = SgAsmPEImportDirectory;
10011 using field_type = Rose::BinaryAnalysis::RelativeVirtualAddress;
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> {
10021 using parent = SgAsmPEImportDirectory;
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> {
10032 using parent = SgAsmPEImportDirectory;
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> {
10043 using parent = SgAsmPEImportDirectory;
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> {
10054 using parent = SgAsmPEImportDirectory;
10055 using field_type = Rose::BinaryAnalysis::RelativeVirtualAddress;
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> {
10065 using parent = SgAsmPEImportDirectory;
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> {
10076 using parent = SgAsmPEImportDirectory;
10077 using field_type = Rose::BinaryAnalysis::RelativeVirtualAddress;
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> {
10087 using parent = SgAsmPEImportDirectory;
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> {
10098 using parent = SgAsmPEImportDirectory;
10099 using field_type = SgAsmPEImportItemList*;
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> {
10121 using parent = SgAsmPEImportDirectoryList;
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};
10131template <> struct describe_node_t<SgAsmPEImportDirectoryList> {
10132 using node = SgAsmPEImportDirectoryList;
10133 using base = SgAsmExecutableFileFormat;
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<>;
10138 using fields_t = mp::List<describe_field_t<SgAsmPEImportDirectoryList,SgAsmPEImportDirectoryPtrList,&SgAsmPEImportDirectoryList::p_vector>>;
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;
10178 using field_type = SgAsmGenericString*;
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;
10189 using field_type = Rose::BinaryAnalysis::RelativeVirtualAddress;
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;
10211 using field_type = Rose::BinaryAnalysis::RelativeVirtualAddress;
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> {
10244 using parent = SgAsmPEImportItemList;
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};
10254template <> struct describe_node_t<SgAsmPEImportItemList> {
10255 using node = SgAsmPEImportItemList;
10256 using base = SgAsmExecutableFileFormat;
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<>;
10261 using fields_t = mp::List<describe_field_t<SgAsmPEImportItemList,SgAsmPEImportItemPtrList,&SgAsmPEImportItemList::p_vector>>;
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> {
10267 using parent = SgAsmPEImportSection;
10268 using field_type = SgAsmPEImportDirectoryList*;
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};
10277template <> struct describe_node_t<SgAsmPEImportSection> {
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<>;
10284 using fields_t = mp::List<describe_field_t<SgAsmPEImportSection,SgAsmPEImportDirectoryList*,&SgAsmPEImportSection::p_importDirectories>>;
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;
10291 using field_type = Rose::BinaryAnalysis::RelativeVirtualAddress;
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;
10313 using field_type = SgAsmGenericSection*;
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> {
10335 using parent = SgAsmPERVASizePairList;
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};
10345template <> struct describe_node_t<SgAsmPERVASizePairList> {
10346 using node = SgAsmPERVASizePairList;
10347 using base = SgAsmExecutableFileFormat;
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<>;
10352 using fields_t = mp::List<describe_field_t<SgAsmPERVASizePairList,SgAsmPERVASizePairPtrList,&SgAsmPERVASizePairList::p_pairs>>;
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;
10359 using field_type = SgAsmPESectionTableEntry*;
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};
10374 using subclasses_t = mp::List<SgAsmPEExportSection, SgAsmPEImportSection, SgAsmPEStringSection>;
10375 using fields_t = mp::List<describe_field_t<SgAsmPESection,SgAsmPESectionTableEntry*,&SgAsmPESection::p_section_entry>>;
10376};
10377template <> struct node_from_variant_t<263> { using type = SgAsmPESection; };
10378
10379// Class: AsmPESectionTable
10380template <> struct describe_node_t<SgAsmPESectionTable> {
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> {
10393 using parent = SgAsmPESectionTableEntry;
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> {
10404 using parent = SgAsmPESectionTableEntry;
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> {
10415 using parent = SgAsmPESectionTableEntry;
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> {
10426 using parent = SgAsmPESectionTableEntry;
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> {
10437 using parent = SgAsmPESectionTableEntry;
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> {
10448 using parent = SgAsmPESectionTableEntry;
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> {
10459 using parent = SgAsmPESectionTableEntry;
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> {
10470 using parent = SgAsmPESectionTableEntry;
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> {
10481 using parent = SgAsmPESectionTableEntry;
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> {
10504 using parent = SgAsmPEStringSection;
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};
10514template <> struct describe_node_t<SgAsmPEStringSection> {
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<>;
10521 using fields_t = mp::List<describe_field_t<SgAsmPEStringSection,SgAsmCoffStrtab*,&SgAsmPEStringSection::p_strtab>>;
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> {
10527 using parent = SgAsmPowerpcInstruction;
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};
10537template <> struct describe_node_t<SgAsmPowerpcInstruction> {
10538 using node = SgAsmPowerpcInstruction;
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<>;
10544 using fields_t = mp::List<describe_field_t<SgAsmPowerpcInstruction,Rose::BinaryAnalysis::PowerpcInstructionKind,&SgAsmPowerpcInstruction::p_kind>>;
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};
10571template <> struct describe_node_t<SgAsmRegisterNames> {
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<>;
10578 using fields_t = mp::List<describe_field_t<SgAsmRegisterNames,SgAsmRegisterReferenceExpressionPtrList,&SgAsmRegisterNames::p_registers>, describe_field_t<SgAsmRegisterNames,unsigned,&SgAsmRegisterNames::p_mask>>;
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> {
10584 using parent = SgAsmRegisterReferenceExpression;
10585 using field_type = Rose::BinaryAnalysis::RegisterDescriptor;
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> {
10595 using parent = SgAsmRegisterReferenceExpression;
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;
10619 using field_type = SgAsmRiscOperation::RiscOperator;
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;
10630 using field_type = SgAsmExprListExp*;
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};
10639template <> struct describe_node_t<SgAsmRiscOperation> {
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<>;
10646 using fields_t = mp::List<describe_field_t<SgAsmRiscOperation,SgAsmRiscOperation::RiscOperator,&SgAsmRiscOperation::p_riscOperator>, describe_field_t<SgAsmRiscOperation,SgAsmExprListExp*,&SgAsmRiscOperation::p_operands>>;
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;
10653 using field_type = Rose::BinaryAnalysis::ByteOrder::Endianness;
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;
10664 using field_type = Rose::BinaryAnalysis::ByteOrder::Endianness;
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};
10735 using subclasses_t = mp::List<SgAsmBlock, SgAsmInstruction, SgAsmStaticData, SgAsmSynthesizedDeclaration>;
10736 using fields_t = mp::List<describe_field_t<SgAsmStatement,Rose::BinaryAnalysis::Address,&SgAsmStatement::p_address>, describe_field_t<SgAsmStatement,std::string,&SgAsmStatement::p_comment>>;
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};
10752template <> struct describe_node_t<SgAsmStaticData> {
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<>;
10759 using fields_t = mp::List<describe_field_t<SgAsmStaticData,SgUnsignedCharList,&SgAsmStaticData::p_rawBytes>>;
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};
10797template <> struct describe_field_t<SgAsmStmt,SgAsmStmt::AsmRegisterNameList,&SgAsmStmt::p_clobberRegisterList> {
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;
10833 using field_type = SgAsmStringStorage*;
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};
10842template <> struct describe_node_t<SgAsmStoredString> {
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<>;
10849 using fields_t = mp::List<describe_field_t<SgAsmStoredString,SgAsmStringStorage*,&SgAsmStoredString::p_storage>>;
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;
10856 using field_type = SgAsmGenericStrtab*;
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};
10887template <> struct describe_node_t<SgAsmStringStorage> {
10888 using node = SgAsmStringStorage;
10889 using base = SgAsmExecutableFileFormat;
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<>;
10894 using fields_t = mp::List<describe_field_t<SgAsmStringStorage,SgAsmGenericStrtab*,&SgAsmStringStorage::p_strtab>, describe_field_t<SgAsmStringStorage,std::string,&SgAsmStringStorage::p_string>, describe_field_t<SgAsmStringStorage,Rose::BinaryAnalysis::Address,&SgAsmStringStorage::p_offset>>;
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};
10905 using subclasses_t = mp::List<SgAsmScalarType, SgAsmVectorType, SgAsmVoidType>;
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> {
10912 using parent = SgAsmUnaryExpression;
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};
10922template <> struct describe_node_t<SgAsmUnaryExpression> {
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};
10928 using subclasses_t = mp::List<SgAsmUnaryMinus, SgAsmUnaryPlus, SgAsmUnaryRrx, SgAsmUnarySignedExtend, SgAsmUnaryTruncate, SgAsmUnaryUnsignedExtend>;
10929 using fields_t = mp::List<describe_field_t<SgAsmUnaryExpression,SgAsmExpression*,&SgAsmUnaryExpression::p_operand>>;
10930};
10931template <> struct node_from_variant_t<278> { using type = SgAsmUnaryExpression; };
10932
10933// Class: AsmUnaryMinus
10934template <> struct describe_node_t<SgAsmUnaryMinus> {
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
10970template <> struct describe_node_t<SgAsmUnarySignedExtend> {
10971 using node = SgAsmUnarySignedExtend;
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
10982template <> struct describe_node_t<SgAsmUnaryUnsignedExtend> {
10983 using node = SgAsmUnaryUnsignedExtend;
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
10994template <> struct describe_node_t<SgAsmUnaryTruncate> {
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> {
11007 using parent = SgAsmValueExpression;
11008 using field_type = SgAsmValueExpression*;
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> {
11018 using parent = SgAsmValueExpression;
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> {
11029 using parent = SgAsmValueExpression;
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> {
11040 using parent = SgAsmValueExpression;
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};
11084template <> struct describe_node_t<SgAsmVectorType> {
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<>;
11091 using fields_t = mp::List<describe_field_t<SgAsmVectorType,size_t,&SgAsmVectorType::p_nElmts>, describe_field_t<SgAsmVectorType,SgAsmType*,&SgAsmVectorType::p_elmtType>>;
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> {
11097 using parent = SgAsmX86Instruction;
11098 using field_type = Rose::BinaryAnalysis::X86InstructionKind;
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> {
11108 using parent = SgAsmX86Instruction;
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> {
11119 using parent = SgAsmX86Instruction;
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> {
11130 using parent = SgAsmX86Instruction;
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> {
11141 using parent = SgAsmX86Instruction;
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> {
11152 using parent = SgAsmX86Instruction;
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> {
11163 using parent = SgAsmX86Instruction;
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> {
11174 using parent = SgAsmX86Instruction;
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> {
11197 using parent = SgAsmBinaryAddressSymbol;
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> {
11208 using parent = SgAsmBinaryAddressSymbol;
11209 using field_type = SgAsmInstruction*;
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};
11218template <> struct describe_node_t<SgAsmBinaryAddressSymbol> {
11219 using node = SgAsmBinaryAddressSymbol;
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<>;
11225 using fields_t = mp::List<describe_field_t<SgAsmBinaryAddressSymbol,SgName,&SgAsmBinaryAddressSymbol::p_address_name>, describe_field_t<SgAsmBinaryAddressSymbol,SgAsmInstruction*,&SgAsmBinaryAddressSymbol::p_address>>;
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> {
11231 using parent = SgAsmBinaryDataSymbol;
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> {
11242 using parent = SgAsmBinaryDataSymbol;
11243 using field_type = SgAsmInstruction*;
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};
11252template <> struct describe_node_t<SgAsmBinaryDataSymbol> {
11253 using node = SgAsmBinaryDataSymbol;
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<>;
11259 using fields_t = mp::List<describe_field_t<SgAsmBinaryDataSymbol,SgName,&SgAsmBinaryDataSymbol::p_variable_name>, describe_field_t<SgAsmBinaryDataSymbol,SgAsmInstruction*,&SgAsmBinaryDataSymbol::p_address>>;
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<>;
11293 using fields_t = mp::List<describe_field_t<SgAssertStmt,SgExpression*,&SgAssertStmt::p_test>, describe_field_t<SgAssertStmt,SgExpression*,&SgAssertStmt::p_exception_argument>>;
11294};
11295template <> struct node_from_variant_t<290> { using type = SgAssertStmt; };
11296
11297// Class: AssignInitializer
11298template <> struct describe_field_t<SgAssignInitializer,SgExpression*,&SgAssignInitializer::p_operand_i> {
11299 using parent = SgAssignInitializer;
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};
11309template <> struct describe_field_t<SgAssignInitializer,SgType*,&SgAssignInitializer::p_expression_type> {
11310 using parent = SgAssignInitializer;
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};
11320template <> struct describe_node_t<SgAssignInitializer> {
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<>;
11327 using fields_t = mp::List<describe_field_t<SgAssignInitializer,SgExpression*,&SgAssignInitializer::p_operand_i>, describe_field_t<SgAssignInitializer,SgType*,&SgAssignInitializer::p_expression_type>>;
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};
11366template <> struct describe_node_t<SgAssignStatement> {
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<>;
11373 using fields_t = mp::List<describe_field_t<SgAssignStatement,SgLabelRefExp*,&SgAssignStatement::p_label>, describe_field_t<SgAssignStatement,SgExpression*,&SgAssignStatement::p_value>>;
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> {
11379 using parent = SgAssignedGotoStatement;
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};
11389template <> struct describe_node_t<SgAssignedGotoStatement> {
11390 using node = SgAssignedGotoStatement;
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<>;
11396 using fields_t = mp::List<describe_field_t<SgAssignedGotoStatement,SgExprListExp*,&SgAssignedGotoStatement::p_targets>>;
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> {
11402 using parent = SgAssociateStatement;
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> {
11413 using parent = SgAssociateStatement;
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};
11423template <> struct describe_node_t<SgAssociateStatement> {
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<>;
11430 using fields_t = mp::List<describe_field_t<SgAssociateStatement,SgDeclarationStatementPtrList,&SgAssociateStatement::p_associates>, describe_field_t<SgAssociateStatement,SgBasicBlock*,&SgAssociateStatement::p_body>>;
11431};
11432template <> struct node_from_variant_t<295> { using type = SgAssociateStatement; };
11433
11434// Class: AsteriskShapeExp
11435template <> struct describe_node_t<SgAsteriskShapeExp> {
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};
11476 using subclasses_t = mp::List<SgPragma, SgBitAttribute>;
11477 using fields_t = mp::List<describe_field_t<SgAttribute,std::string,&SgAttribute::p_name>>;
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> {
11483 using parent = SgAttributeSpecificationStatement;
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> {
11494 using parent = SgAttributeSpecificationStatement;
11495 using field_type = SgAttributeSpecificationStatement::attribute_spec_enum;
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> {
11505 using parent = SgAttributeSpecificationStatement;
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> {
11516 using parent = SgAttributeSpecificationStatement;
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> {
11527 using parent = SgAttributeSpecificationStatement;
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> {
11538 using parent = SgAttributeSpecificationStatement;
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> {
11549 using parent = SgAttributeSpecificationStatement;
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};
11594template <> struct describe_node_t<SgAwaitExpression> {
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<>;
11601 using fields_t = mp::List<describe_field_t<SgAwaitExpression,SgExpression*,&SgAwaitExpression::p_value>>;
11602};
11603template <> struct node_from_variant_t<301> { using type = SgAwaitExpression; };
11604
11605// Class: BackspaceStatement
11606template <> struct describe_node_t<SgBackspaceStatement> {
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;
11620 using field_type = SgClassDeclaration*;
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;
11642 using field_type = SgBaseClassModifier*;
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<>;
11714 using fields_t = mp::List<describe_field_t<SgExpBaseClass,SgExpression*,&SgExpBaseClass::p_base_class_exp>>;
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> {
11720 using parent = SgBaseClassModifier;
11721 using field_type = SgBaseClassModifier::baseclass_modifier_enum;
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> {
11731 using parent = SgBaseClassModifier;
11732 using field_type = SgAccessModifier;
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};
11741template <> struct describe_node_t<SgBaseClassModifier> {
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<>;
11748 using fields_t = mp::List<describe_field_t<SgBaseClassModifier,SgBaseClassModifier::baseclass_modifier_enum,&SgBaseClassModifier::p_modifier>, describe_field_t<SgBaseClassModifier,SgAccessModifier,&SgBaseClassModifier::p_accessModifier>>;
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<>;
11793 using fields_t = mp::List<describe_field_t<SgBasicBlock,SgStatementPtrList,&SgBasicBlock::p_statements>, describe_field_t<SgBasicBlock,std::string,&SgBasicBlock::p_asm_function_body>, describe_field_t<SgBasicBlock,std::string,&SgBasicBlock::p_string_label>>;
11794};
11795template <> struct node_from_variant_t<306> { using type = SgBasicBlock; };
11796
11797// Class: BidirectionalGraph
11798template <> struct describe_node_t<SgBidirectionalGraph> {
11799 using node = SgBidirectionalGraph;
11800 using base = SgIncidenceDirectedGraph;
11801 static constexpr char const * const name{"BidirectionalGraph"};
11802 static constexpr unsigned long variant{307};
11803 static constexpr bool concrete{false};
11804 using subclasses_t = mp::List<SgStringKeyedBidirectionalGraph, SgIntKeyedBidirectionalGraph>;
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;
11812 using field_type = SgAsmGenericFileList*;
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;
11823 using field_type = SgAsmInterpretationList*;
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};
11832template <> struct describe_node_t<SgBinaryComposite> {
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};
11838 using subclasses_t = mp::List<SgJvmComposite>;
11839 using fields_t = mp::List<describe_field_t<SgBinaryComposite,SgAsmGenericFileList*,&SgBinaryComposite::p_genericFileList>, describe_field_t<SgBinaryComposite,SgAsmInterpretationList*,&SgBinaryComposite::p_interpretations>>;
11840};
11841template <> struct node_from_variant_t<308> { using type = SgBinaryComposite; };
11842
11843// Class: BinaryOp
11844template <> struct describe_field_t<SgBinaryOp,SgExpression*,&SgBinaryOp::p_lhs_operand_i> {
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};
11855template <> struct describe_field_t<SgBinaryOp,SgExpression*,&SgBinaryOp::p_rhs_operand_i> {
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};
11866template <> struct describe_field_t<SgBinaryOp,SgType*,&SgBinaryOp::p_expression_type> {
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};
11929 using subclasses_t = mp::List<SgFuncDecl_attr, SgClassDecl_attr>;
11930 using fields_t = mp::List<describe_field_t<SgBitAttribute,unsigned long int,&SgBitAttribute::p_bitflag>>;
11931};
11932template <> struct node_from_variant_t<311> { using type = SgBitAttribute; };
11933
11934// Class: BitComplementOp
11935template <> struct describe_node_t<SgBitComplementOp> {
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> {
11984 using parent = SgBlockDataStatement;
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};
11994template <> struct describe_node_t<SgBlockDataStatement> {
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<>;
12001 using fields_t = mp::List<describe_field_t<SgBlockDataStatement,SgBasicBlock*,&SgBlockDataStatement::p_body>>;
12002};
12003template <> struct node_from_variant_t<316> { using type = SgBlockDataStatement; };
12004
12005// Class: BoolValExp
12006template <> struct describe_field_t<SgBoolValExp,int,&SgBoolValExp::p_value> {
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<>;
12024 using fields_t = mp::List<describe_field_t<SgBoolValExp,int,&SgBoolValExp::p_value>>;
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<>;
12047 using fields_t = mp::List<describe_field_t<SgBreakStmt,std::string,&SgBreakStmt::p_do_string_label>>;
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> {
12053 using parent = SgBracedInitializer;
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> {
12064 using parent = SgBracedInitializer;
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};
12074template <> struct describe_node_t<SgBracedInitializer> {
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<>;
12081 using fields_t = mp::List<describe_field_t<SgBracedInitializer,SgExprListExp*,&SgBracedInitializer::p_initializers>, describe_field_t<SgBracedInitializer,SgType*,&SgBracedInitializer::p_expression_type>>;
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> {
12087 using parent = SgC_PreprocessorDirectiveStatement;
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};
12120template <> struct describe_field_t<SgCaseOptionStmt,SgStatement*,&SgCaseOptionStmt::p_body> {
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};
12131template <> struct describe_field_t<SgCaseOptionStmt,SgExpression*,&SgCaseOptionStmt::p_key_range_end> {
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;
12178 using field_type = SgCastExp::cast_type_enum;
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
12287template <> struct describe_field_t<SgCatchOptionStmt,SgVariableDeclaration*,&SgCatchOptionStmt::p_condition> {
12288 using parent = SgCatchOptionStmt;
12289 using field_type = SgVariableDeclaration*;
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};
12298template <> struct describe_field_t<SgCatchOptionStmt,SgStatement*,&SgCatchOptionStmt::p_body> {
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};
12309template <> struct describe_field_t<SgCatchOptionStmt,SgTryStmt*,&SgCatchOptionStmt::p_trystmt> {
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};
12320template <> struct describe_node_t<SgCatchOptionStmt> {
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<>;
12327 using fields_t = mp::List<describe_field_t<SgCatchOptionStmt,SgVariableDeclaration*,&SgCatchOptionStmt::p_condition>, describe_field_t<SgCatchOptionStmt,SgStatement*,&SgCatchOptionStmt::p_body>, describe_field_t<SgCatchOptionStmt,SgTryStmt*,&SgCatchOptionStmt::p_trystmt>>;
12328};
12329template <> struct node_from_variant_t<323> { using type = SgCatchOptionStmt; };
12330
12331// Class: CatchStatementSeq
12332template <> struct describe_field_t<SgCatchStatementSeq,SgStatementPtrList,&SgCatchStatementSeq::p_catch_statement_seq> {
12333 using parent = SgCatchStatementSeq;
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};
12343template <> struct describe_node_t<SgCatchStatementSeq> {
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<>;
12350 using fields_t = mp::List<describe_field_t<SgCatchStatementSeq,SgStatementPtrList,&SgCatchStatementSeq::p_catch_statement_seq>>;
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<>;
12384 using fields_t = mp::List<describe_field_t<SgCharVal,char,&SgCharVal::p_value>, describe_field_t<SgCharVal,std::string,&SgCharVal::p_valueString>>;
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<>;
12418 using fields_t = mp::List<describe_field_t<SgChar16Val,unsigned short,&SgChar16Val::p_valueUL>, describe_field_t<SgChar16Val,std::string,&SgChar16Val::p_valueString>>;
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<>;
12452 using fields_t = mp::List<describe_field_t<SgChar32Val,unsigned int,&SgChar32Val::p_valueUL>, describe_field_t<SgChar32Val,std::string,&SgChar32Val::p_valueString>>;
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};
12468template <> struct describe_node_t<SgChooseExpression> {
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<>;
12475 using fields_t = mp::List<describe_field_t<SgChooseExpression,SgExpression*,&SgChooseExpression::p_value>>;
12476};
12477template <> struct node_from_variant_t<328> { using type = SgChooseExpression; };
12478
12479// Class: ClassDecl_attr
12480template <> struct describe_node_t<SgClassDecl_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
12492template <> struct describe_field_t<SgClassDeclaration,SgName,&SgClassDeclaration::p_name> {
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};
12503template <> struct describe_field_t<SgClassDeclaration,SgClassDeclaration::class_types,&SgClassDeclaration::p_class_type> {
12504 using parent = SgClassDeclaration;
12505 using field_type = SgClassDeclaration::class_types;
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};
12514template <> struct describe_field_t<SgClassDeclaration,SgClassType*,&SgClassDeclaration::p_type> {
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};
12525template <> struct describe_field_t<SgClassDeclaration,SgClassDefinition*,&SgClassDeclaration::p_definition> {
12526 using parent = SgClassDeclaration;
12527 using field_type = SgClassDefinition*;
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;
12538 using field_type = SgScopeStatement*;
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;
12549 using field_type = SgDeclarationStatement::template_specialization_enum;
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};
12558template <> struct describe_field_t<SgClassDeclaration,bool,&SgClassDeclaration::p_from_template> {
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};
12712template <> struct describe_node_t<SgClassDeclaration> {
12713 using node = SgClassDeclaration;
12714 using base = SgDeclarationStatement;
12715 static constexpr char const * const name{"ClassDeclaration"};
12716 static constexpr unsigned long variant{330};
12717 static constexpr bool concrete{true};
12718 using subclasses_t = mp::List<SgTemplateClassDeclaration, SgTemplateInstantiationDecl, SgDerivedTypeStatement, SgModuleStatement, SgJavaPackageDeclaration, SgJovialTableStatement>;
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};
12735template <> struct describe_field_t<SgClassDefinition,SgBaseClassPtrList,&SgClassDefinition::p_inheritances> {
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
12802template <> struct describe_field_t<SgClassNameRefExp,SgClassSymbol*,&SgClassNameRefExp::p_symbol> {
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};
12813template <> struct describe_node_t<SgClassNameRefExp> {
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<>;
12820 using fields_t = mp::List<describe_field_t<SgClassNameRefExp,SgClassSymbol*,&SgClassNameRefExp::p_symbol>>;
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;
12827 using field_type = SgClassDeclaration*;
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};
12842 using subclasses_t = mp::List<SgTemplateClassSymbol>;
12843 using fields_t = mp::List<describe_field_t<SgClassSymbol,SgClassDeclaration*,&SgClassSymbol::p_declaration>>;
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};
12865 using subclasses_t = mp::List<SgJavaParameterType, SgJovialTableType>;
12866 using fields_t = mp::List<describe_field_t<SgClassType,bool,&SgClassType::p_packed>>;
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> {
12872 using parent = SgClinkageDeclarationStatement;
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};
12882template <> struct describe_node_t<SgClinkageDeclarationStatement> {
12883 using node = SgClinkageDeclarationStatement;
12884 using base = SgDeclarationStatement;
12885 static constexpr char const * const name{"ClinkageDeclarationStatement"};
12886 static constexpr unsigned long variant{335};
12887 static constexpr bool concrete{false};
12888 using subclasses_t = mp::List<SgClinkageStartStatement, SgClinkageEndStatement>;
12889 using fields_t = mp::List<describe_field_t<SgClinkageDeclarationStatement,std::string,&SgClinkageDeclarationStatement::p_languageSpecifier>>;
12890};
12891template <> struct node_from_variant_t<335> { using type = SgClinkageDeclarationStatement; };
12892
12893// Class: ClinkageEndStatement
12894template <> struct describe_node_t<SgClinkageEndStatement> {
12895 using node = SgClinkageEndStatement;
12896 using base = SgClinkageDeclarationStatement;
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
12906template <> struct describe_node_t<SgClinkageStartStatement> {
12907 using node = SgClinkageStartStatement;
12908 using base = SgClinkageDeclarationStatement;
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};
12929template <> struct describe_node_t<SgCloseStatement> {
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<>;
12936 using fields_t = mp::List<describe_field_t<SgCloseStatement,SgExpression*,&SgCloseStatement::p_status>>;
12937};
12938template <> struct node_from_variant_t<338> { using type = SgCloseStatement; };
12939
12940// Class: ColonShapeExp
12941template <> struct describe_node_t<SgColonShapeExp> {
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;
12978 using base = SgDeclarationStatement;
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<>;
12983 using fields_t = mp::List<describe_field_t<SgCommonBlock,SgCommonBlockObjectPtrList,&SgCommonBlock::p_block_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> {
12989 using parent = SgCommonBlockObject;
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> {
13000 using parent = SgCommonBlockObject;
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};
13010template <> struct describe_node_t<SgCommonBlockObject> {
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<>;
13017 using fields_t = mp::List<describe_field_t<SgCommonBlockObject,std::string,&SgCommonBlockObject::p_block_name>, describe_field_t<SgCommonBlockObject,SgExprListExp*,&SgCommonBlockObject::p_variable_reference_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;
13024 using field_type = SgInitializedName*;
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<>;
13040 using fields_t = mp::List<describe_field_t<SgCommonSymbol,SgInitializedName*,&SgCommonSymbol::p_declaration>>;
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<>;
13096 using fields_t = mp::List<describe_field_t<SgComplexVal,SgValueExp*,&SgComplexVal::p_real_value>, describe_field_t<SgComplexVal,SgValueExp*,&SgComplexVal::p_imaginary_value>, describe_field_t<SgComplexVal,SgType*,&SgComplexVal::p_precisionType>, describe_field_t<SgComplexVal,std::string,&SgComplexVal::p_valueString>>;
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};
13134template <> struct describe_node_t<SgComprehension> {
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<>;
13141 using fields_t = mp::List<describe_field_t<SgComprehension,SgExpression*,&SgComprehension::p_target>, describe_field_t<SgComprehension,SgExpression*,&SgComprehension::p_iter>, describe_field_t<SgComprehension,SgExprListExp*,&SgComprehension::p_filters>>;
13142};
13143template <> struct node_from_variant_t<345> { using type = SgComprehension; };
13144
13145// Class: CompoundAssignOp
13146template <> struct describe_node_t<SgCompoundAssignOp> {
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};
13152 using subclasses_t = mp::List<SgPlusAssignOp, SgMinusAssignOp, SgAndAssignOp, SgIorAssignOp, SgMultAssignOp, SgDivAssignOp, SgModAssignOp, SgXorAssignOp, SgLshiftAssignOp, SgRshiftAssignOp, SgJavaUnsignedRshiftAssignOp, SgIntegerDivideAssignOp, SgExponentiationAssignOp>;
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> {
13159 using parent = SgCompoundInitializer;
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> {
13170 using parent = SgCompoundInitializer;
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};
13180template <> struct describe_node_t<SgCompoundInitializer> {
13181 using node = SgCompoundInitializer;
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<>;
13187 using fields_t = mp::List<describe_field_t<SgCompoundInitializer,SgExprListExp*,&SgCompoundInitializer::p_initializers>, describe_field_t<SgCompoundInitializer,SgType*,&SgCompoundInitializer::p_expression_type>>;
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> {
13193 using parent = SgCompoundLiteralExp;
13194 using field_type = SgVariableSymbol*;
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};
13203template <> struct describe_node_t<SgCompoundLiteralExp> {
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<>;
13210 using fields_t = mp::List<describe_field_t<SgCompoundLiteralExp,SgVariableSymbol*,&SgCompoundLiteralExp::p_symbol>>;
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> {
13216 using parent = SgComputedGotoStatement;
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> {
13227 using parent = SgComputedGotoStatement;
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};
13237template <> struct describe_node_t<SgComputedGotoStatement> {
13238 using node = SgComputedGotoStatement;
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<>;
13244 using fields_t = mp::List<describe_field_t<SgComputedGotoStatement,SgExprListExp*,&SgComputedGotoStatement::p_labelList>, describe_field_t<SgComputedGotoStatement,SgExpression*,&SgComputedGotoStatement::p_label_index>>;
13245};
13246template <> struct node_from_variant_t<350> { using type = SgComputedGotoStatement; };
13247
13248// Class: ConcatenationOp
13249template <> struct describe_node_t<SgConcatenationOp> {
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
13261template <> struct describe_field_t<SgConditionalExp,SgExpression*,&SgConditionalExp::p_conditional_exp> {
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};
13272template <> struct describe_field_t<SgConditionalExp,SgExpression*,&SgConditionalExp::p_true_exp> {
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};
13283template <> struct describe_field_t<SgConditionalExp,SgExpression*,&SgConditionalExp::p_false_exp> {
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};
13294template <> struct describe_field_t<SgConditionalExp,SgType*,&SgConditionalExp::p_expression_type> {
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> {
13330 using parent = SgConstVolatileModifier;
13331 using field_type = SgConstVolatileModifier::cv_modifier_enum;
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};
13340template <> struct describe_node_t<SgConstVolatileModifier> {
13341 using node = SgConstVolatileModifier;
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<>;
13347 using fields_t = mp::List<describe_field_t<SgConstVolatileModifier,SgConstVolatileModifier::cv_modifier_enum,&SgConstVolatileModifier::p_modifier>>;
13348};
13349template <> struct node_from_variant_t<354> { using type = SgConstVolatileModifier; };
13350
13351// Class: ConstructorInitializer
13352template <> struct describe_field_t<SgConstructorInitializer,SgMemberFunctionDeclaration*,&SgConstructorInitializer::p_declaration> {
13353 using parent = SgConstructorInitializer;
13354 using field_type = SgMemberFunctionDeclaration*;
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};
13363template <> struct describe_field_t<SgConstructorInitializer,SgExprListExp*,&SgConstructorInitializer::p_args> {
13364 using parent = SgConstructorInitializer;
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};
13374template <> struct describe_field_t<SgConstructorInitializer,SgType*,&SgConstructorInitializer::p_expression_type> {
13375 using parent = SgConstructorInitializer;
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};
13385template <> struct describe_field_t<SgConstructorInitializer,bool,&SgConstructorInitializer::p_need_name> {
13386 using parent = SgConstructorInitializer;
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};
13396template <> struct describe_field_t<SgConstructorInitializer,bool,&SgConstructorInitializer::p_need_qualifier> {
13397 using parent = SgConstructorInitializer;
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};
13407template <> struct describe_field_t<SgConstructorInitializer,bool,&SgConstructorInitializer::p_need_parenthesis_after_name> {
13408 using parent = SgConstructorInitializer;
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};
13418template <> struct describe_field_t<SgConstructorInitializer,bool,&SgConstructorInitializer::p_associated_class_unknown> {
13419 using parent = SgConstructorInitializer;
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> {
13430 using parent = SgConstructorInitializer;
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> {
13441 using parent = SgConstructorInitializer;
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> {
13452 using parent = SgConstructorInitializer;
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> {
13463 using parent = SgConstructorInitializer;
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};
13473template <> struct describe_node_t<SgConstructorInitializer> {
13474 using node = SgConstructorInitializer;
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<>;
13480 using fields_t = mp::List<describe_field_t<SgConstructorInitializer,SgMemberFunctionDeclaration*,&SgConstructorInitializer::p_declaration>, describe_field_t<SgConstructorInitializer,SgExprListExp*,&SgConstructorInitializer::p_args>, describe_field_t<SgConstructorInitializer,SgType*,&SgConstructorInitializer::p_expression_type>, describe_field_t<SgConstructorInitializer,bool,&SgConstructorInitializer::p_need_name>, describe_field_t<SgConstructorInitializer,bool,&SgConstructorInitializer::p_need_qualifier>, describe_field_t<SgConstructorInitializer,bool,&SgConstructorInitializer::p_need_parenthesis_after_name>, describe_field_t<SgConstructorInitializer,bool,&SgConstructorInitializer::p_associated_class_unknown>, describe_field_t<SgConstructorInitializer,int,&SgConstructorInitializer::p_name_qualification_length>, describe_field_t<SgConstructorInitializer,bool,&SgConstructorInitializer::p_type_elaboration_required>, describe_field_t<SgConstructorInitializer,bool,&SgConstructorInitializer::p_global_qualification_required>, describe_field_t<SgConstructorInitializer,bool,&SgConstructorInitializer::p_is_used_in_conditional>>;
13481};
13482template <> struct node_from_variant_t<355> { using type = SgConstructorInitializer; };
13483
13484// Class: ContainsStatement
13485template <> struct describe_node_t<SgContainsStatement> {
13486 using node = SgContainsStatement;
13487 using base = SgDeclarationStatement;
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<>;
13515 using fields_t = mp::List<describe_field_t<SgContinueStmt,std::string,&SgContinueStmt::p_do_string_label>>;
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> {
13521 using parent = SgCtorInitializerList;
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};
13531template <> struct describe_node_t<SgCtorInitializerList> {
13532 using node = SgCtorInitializerList;
13533 using base = SgDeclarationStatement;
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<>;
13538 using fields_t = mp::List<describe_field_t<SgCtorInitializerList,SgInitializedNamePtrList,&SgCtorInitializerList::p_ctors>>;
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> {
13544 using parent = SgDataStatementGroup;
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> {
13555 using parent = SgDataStatementGroup;
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};
13565template <> struct describe_node_t<SgDataStatementGroup> {
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<>;
13572 using fields_t = mp::List<describe_field_t<SgDataStatementGroup,SgDataStatementObjectPtrList,&SgDataStatementGroup::p_object_list>, describe_field_t<SgDataStatementGroup,SgDataStatementValuePtrList,&SgDataStatementGroup::p_value_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> {
13578 using parent = SgDataStatementObject;
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};
13588template <> struct describe_node_t<SgDataStatementObject> {
13589 using node = SgDataStatementObject;
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<>;
13595 using fields_t = mp::List<describe_field_t<SgDataStatementObject,SgExprListExp*,&SgDataStatementObject::p_variableReference_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> {
13601 using parent = SgDataStatementValue;
13602 using field_type = SgDataStatementValue::data_statement_value_enum;
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> {
13612 using parent = SgDataStatementValue;
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> {
13623 using parent = SgDataStatementValue;
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> {
13634 using parent = SgDataStatementValue;
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
13656template <> struct describe_node_t<SgDeadIfDirectiveStatement> {
13657 using node = SgDeadIfDirectiveStatement;
13658 using base = SgC_PreprocessorDirectiveStatement;
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> {
13669 using parent = SgDeallocateStatement;
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> {
13680 using parent = SgDeallocateStatement;
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> {
13691 using parent = SgDeallocateStatement;
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};
13701template <> struct describe_node_t<SgDeallocateStatement> {
13702 using node = SgDeallocateStatement;
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<>;
13708 using fields_t = mp::List<describe_field_t<SgDeallocateStatement,SgExprListExp*,&SgDeallocateStatement::p_expr_list>, describe_field_t<SgDeallocateStatement,SgExpression*,&SgDeallocateStatement::p_stat_expression>, describe_field_t<SgDeallocateStatement,SgExpression*,&SgDeallocateStatement::p_errmsg_expression>>;
13709};
13710template <> struct node_from_variant_t<363> { using type = SgDeallocateStatement; };
13711
13712// Class: DeclarationModifier
13713template <> struct describe_field_t<SgDeclarationModifier,SgBitVector,&SgDeclarationModifier::p_modifierVector> {
13714 using parent = SgDeclarationModifier;
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};
13724template <> struct describe_field_t<SgDeclarationModifier,SgTypeModifier,&SgDeclarationModifier::p_typeModifier> {
13725 using parent = SgDeclarationModifier;
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};
13735template <> struct describe_field_t<SgDeclarationModifier,SgAccessModifier,&SgDeclarationModifier::p_accessModifier> {
13736 using parent = SgDeclarationModifier;
13737 using field_type = SgAccessModifier;
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};
13746template <> struct describe_field_t<SgDeclarationModifier,SgStorageModifier,&SgDeclarationModifier::p_storageModifier> {
13747 using parent = SgDeclarationModifier;
13748 using field_type = SgStorageModifier;
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> {
13758 using parent = SgDeclarationModifier;
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> {
13769 using parent = SgDeclarationModifier;
13770 using field_type = SgDeclarationModifier::gnu_declaration_visability_enum;
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> {
13780 using parent = SgDeclarationModifier;
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> {
13791 using parent = SgDeclarationModifier;
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> {
13802 using parent = SgDeclarationModifier;
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
13824template <> struct describe_node_t<SgDeclarationScope> {
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
13836template <> struct describe_field_t<SgDeclarationStatement,unsigned int,&SgDeclarationStatement::p_decl_attributes> {
13837 using parent = SgDeclarationStatement;
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};
13847template <> struct describe_field_t<SgDeclarationStatement,std::string,&SgDeclarationStatement::p_linkage> {
13848 using parent = SgDeclarationStatement;
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};
13858template <> struct describe_field_t<SgDeclarationStatement,SgDeclarationModifier,&SgDeclarationStatement::p_declarationModifier> {
13859 using parent = SgDeclarationStatement;
13860 using field_type = SgDeclarationModifier;
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};
13869template <> struct describe_field_t<SgDeclarationStatement,bool,&SgDeclarationStatement::p_nameOnly> {
13870 using parent = SgDeclarationStatement;
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};
13880template <> struct describe_field_t<SgDeclarationStatement,bool,&SgDeclarationStatement::p_forward> {
13881 using parent = SgDeclarationStatement;
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};
13891template <> struct describe_field_t<SgDeclarationStatement,bool,&SgDeclarationStatement::p_externBrace> {
13892 using parent = SgDeclarationStatement;
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};
13902template <> struct describe_field_t<SgDeclarationStatement,bool,&SgDeclarationStatement::p_skipElaborateType> {
13903 using parent = SgDeclarationStatement;
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};
13913template <> struct describe_field_t<SgDeclarationStatement,SgDeclarationStatement*,&SgDeclarationStatement::p_definingDeclaration> {
13914 using parent = SgDeclarationStatement;
13915 using field_type = SgDeclarationStatement*;
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};
13924template <> struct describe_field_t<SgDeclarationStatement,SgDeclarationStatement*,&SgDeclarationStatement::p_firstNondefiningDeclaration> {
13925 using parent = SgDeclarationStatement;
13926 using field_type = SgDeclarationStatement*;
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> {
13936 using parent = SgDeclarationStatement;
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> {
13947 using parent = SgDeclarationStatement;
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> {
13958 using parent = SgDeclarationStatement;
13959 using field_type = SgDeclarationScope*;
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> {
13969 using parent = SgDeclarationStatement;
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> {
13980 using parent = SgDeclarationStatement;
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};
13990template <> struct describe_node_t<SgDeclarationStatement> {
13991 using node = SgDeclarationStatement;
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>;
13997 using fields_t = mp::List<describe_field_t<SgDeclarationStatement,unsigned int,&SgDeclarationStatement::p_decl_attributes>, describe_field_t<SgDeclarationStatement,std::string,&SgDeclarationStatement::p_linkage>, describe_field_t<SgDeclarationStatement,SgDeclarationModifier,&SgDeclarationStatement::p_declarationModifier>, describe_field_t<SgDeclarationStatement,bool,&SgDeclarationStatement::p_nameOnly>, describe_field_t<SgDeclarationStatement,bool,&SgDeclarationStatement::p_forward>, describe_field_t<SgDeclarationStatement,bool,&SgDeclarationStatement::p_externBrace>, describe_field_t<SgDeclarationStatement,bool,&SgDeclarationStatement::p_skipElaborateType>, describe_field_t<SgDeclarationStatement,SgDeclarationStatement*,&SgDeclarationStatement::p_definingDeclaration>, describe_field_t<SgDeclarationStatement,SgDeclarationStatement*,&SgDeclarationStatement::p_firstNondefiningDeclaration>, describe_field_t<SgDeclarationStatement,SgQualifiedNamePtrList,&SgDeclarationStatement::p_qualifiedNameList>, describe_field_t<SgDeclarationStatement,std::string,&SgDeclarationStatement::p_binding_label>, describe_field_t<SgDeclarationStatement,SgDeclarationScope*,&SgDeclarationStatement::p_declarationScope>, describe_field_t<SgDeclarationStatement,bool,&SgDeclarationStatement::p_unparse_template_ast>, describe_field_t<SgDeclarationStatement,SgExprListExp*,&SgDeclarationStatement::p_adaAspects>>;
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<>;
14031 using fields_t = mp::List<describe_field_t<SgDeclType,SgExpression*,&SgDeclType::p_base_expression>, describe_field_t<SgDeclType,SgType*,&SgDeclType::p_base_type>>;
14032};
14033template <> struct node_from_variant_t<367> { using type = SgDeclType; };
14034
14035// Class: DefaultOptionStmt
14036template <> struct describe_field_t<SgDefaultOptionStmt,SgStatement*,&SgDefaultOptionStmt::p_body> {
14037 using parent = SgDefaultOptionStmt;
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> {
14048 using parent = SgDefaultOptionStmt;
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> {
14059 using parent = SgDefaultOptionStmt;
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};
14069template <> struct describe_node_t<SgDefaultOptionStmt> {
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<>;
14076 using fields_t = mp::List<describe_field_t<SgDefaultOptionStmt,SgStatement*,&SgDefaultOptionStmt::p_body>, describe_field_t<SgDefaultOptionStmt,std::string,&SgDefaultOptionStmt::p_default_construct_name>, describe_field_t<SgDefaultOptionStmt,bool,&SgDefaultOptionStmt::p_has_fall_through>>;
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};
14092template <> struct describe_node_t<SgDefaultSymbol> {
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<>;
14099 using fields_t = mp::List<describe_field_t<SgDefaultSymbol,SgType*,&SgDefaultSymbol::p_type>>;
14100};
14101template <> struct node_from_variant_t<369> { using type = SgDefaultSymbol; };
14102
14103// Class: DefineDirectiveStatement
14104template <> struct describe_node_t<SgDefineDirectiveStatement> {
14105 using node = SgDefineDirectiveStatement;
14106 using base = SgC_PreprocessorDirectiveStatement;
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
14116template <> struct describe_field_t<SgDeleteExp,SgExpression*,&SgDeleteExp::p_variable> {
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};
14127template <> struct describe_field_t<SgDeleteExp,short,&SgDeleteExp::p_is_array> {
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};
14138template <> struct describe_field_t<SgDeleteExp,short,&SgDeleteExp::p_need_global_specifier> {
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;
14151 using field_type = SgFunctionDeclaration*;
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<>;
14167 using fields_t = mp::List<describe_field_t<SgDeleteExp,SgExpression*,&SgDeleteExp::p_variable>, describe_field_t<SgDeleteExp,short,&SgDeleteExp::p_is_array>, describe_field_t<SgDeleteExp,short,&SgDeleteExp::p_need_global_specifier>, describe_field_t<SgDeleteExp,SgFunctionDeclaration*,&SgDeleteExp::p_deleteOperatorDeclaration>>;
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> {
14173 using parent = SgDerivedTypeStatement;
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};
14183template <> struct describe_node_t<SgDerivedTypeStatement> {
14184 using node = SgDerivedTypeStatement;
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<>;
14190 using fields_t = mp::List<describe_field_t<SgDerivedTypeStatement,SgLabelRefExp*,&SgDerivedTypeStatement::p_end_numeric_label>>;
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> {
14196 using parent = SgDesignatedInitializer;
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> {
14207 using parent = SgDesignatedInitializer;
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};
14217template <> struct describe_node_t<SgDesignatedInitializer> {
14218 using node = SgDesignatedInitializer;
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<>;
14224 using fields_t = mp::List<describe_field_t<SgDesignatedInitializer,SgExprListExp*,&SgDesignatedInitializer::p_designatorList>, describe_field_t<SgDesignatedInitializer,SgInitializer*,&SgDesignatedInitializer::p_memberInit>>;
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> {
14230 using parent = SgDictionaryComprehension;
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> {
14241 using parent = SgDictionaryComprehension;
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};
14251template <> struct describe_node_t<SgDictionaryComprehension> {
14252 using node = SgDictionaryComprehension;
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<>;
14258 using fields_t = mp::List<describe_field_t<SgDictionaryComprehension,SgKeyDatumPair*,&SgDictionaryComprehension::p_element>, describe_field_t<SgDictionaryComprehension,SgExprListExp*,&SgDictionaryComprehension::p_generators>>;
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};
14274template <> struct describe_node_t<SgDictionaryExp> {
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<>;
14281 using fields_t = mp::List<describe_field_t<SgDictionaryExp,SgKeyDatumPairPtrList,&SgDictionaryExp::p_key_datum_pairs>>;
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;
14288 using field_type = SgInitializedName*;
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};
14308template <> struct describe_node_t<SgDimensionObject> {
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<>;
14315 using fields_t = mp::List<describe_field_t<SgDimensionObject,SgInitializedName*,&SgDimensionObject::p_array>, describe_field_t<SgDimensionObject,SgExprListExp*,&SgDimensionObject::p_shape>>;
14316};
14317template <> struct node_from_variant_t<376> { using type = SgDimensionObject; };
14318
14319// Class: DirectedGraphEdge
14320template <> struct describe_node_t<SgDirectedGraphEdge> {
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;
14367 using field_type = AstAttributeMechanism*;
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<>;
14383 using fields_t = mp::List<describe_field_t<SgDirectory,std::string,&SgDirectory::p_name>, describe_field_t<SgDirectory,SgFileList*,&SgDirectory::p_fileList>, describe_field_t<SgDirectory,SgDirectoryList*,&SgDirectory::p_directoryList>, describe_field_t<SgDirectory,AstAttributeMechanism*,&SgDirectory::p_attributeMechanism>>;
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};
14399template <> struct describe_node_t<SgDirectoryList> {
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<>;
14406 using fields_t = mp::List<describe_field_t<SgDirectoryList,SgDirectoryPtrList,&SgDirectoryList::p_listOfDirectories>>;
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
14435template <> struct describe_field_t<SgDoWhileStmt,SgStatement*,&SgDoWhileStmt::p_body> {
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};
14446template <> struct describe_field_t<SgDoWhileStmt,SgStatement*,&SgDoWhileStmt::p_condition> {
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<>;
14464 using fields_t = mp::List<describe_field_t<SgDoWhileStmt,SgStatement*,&SgDoWhileStmt::p_body>, describe_field_t<SgDoWhileStmt,SgStatement*,&SgDoWhileStmt::p_condition>>;
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
14493template <> struct describe_field_t<SgDoubleVal,double,&SgDoubleVal::p_value> {
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<>;
14522 using fields_t = mp::List<describe_field_t<SgDoubleVal,double,&SgDoubleVal::p_value>, describe_field_t<SgDoubleVal,std::string,&SgDoubleVal::p_valueString>>;
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> {
14528 using parent = SgElaboratedTypeModifier;
14529 using field_type = SgElaboratedTypeModifier::elaborated_type_modifier_enum;
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};
14538template <> struct describe_node_t<SgElaboratedTypeModifier> {
14539 using node = SgElaboratedTypeModifier;
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<>;
14545 using fields_t = mp::List<describe_field_t<SgElaboratedTypeModifier,SgElaboratedTypeModifier::elaborated_type_modifier_enum,&SgElaboratedTypeModifier::p_modifier>>;
14546};
14547template <> struct node_from_variant_t<388> { using type = SgElaboratedTypeModifier; };
14548
14549// Class: ElementwiseOp
14550template <> struct describe_node_t<SgElementwiseOp> {
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};
14556 using subclasses_t = mp::List<SgElementwiseMultiplyOp, SgElementwisePowerOp, SgElementwiseLeftDivideOp, SgElementwiseDivideOp, SgElementwiseAddOp, SgElementwiseSubtractOp>;
14557 using fields_t = mp::List<>;
14558};
14559template <> struct node_from_variant_t<389> { using type = SgElementwiseOp; };
14560
14561// Class: ElementwiseAddOp
14562template <> struct describe_node_t<SgElementwiseAddOp> {
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
14574template <> struct describe_node_t<SgElementwiseDivideOp> {
14575 using node = SgElementwiseDivideOp;
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
14586template <> struct describe_node_t<SgElementwiseLeftDivideOp> {
14587 using node = SgElementwiseLeftDivideOp;
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
14598template <> struct describe_node_t<SgElementwiseMultiplyOp> {
14599 using node = SgElementwiseMultiplyOp;
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
14610template <> struct describe_node_t<SgElementwisePowerOp> {
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
14622template <> struct describe_node_t<SgElementwiseSubtractOp> {
14623 using node = SgElementwiseSubtractOp;
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
14634template <> struct describe_node_t<SgElseDirectiveStatement> {
14635 using node = SgElseDirectiveStatement;
14636 using base = SgC_PreprocessorDirectiveStatement;
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> {
14647 using parent = SgElseWhereStatement;
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> {
14658 using parent = SgElseWhereStatement;
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> {
14669 using parent = SgElseWhereStatement;
14670 using field_type = SgElseWhereStatement*;
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};
14679template <> struct describe_node_t<SgElseWhereStatement> {
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<>;
14686 using fields_t = mp::List<describe_field_t<SgElseWhereStatement,SgExpression*,&SgElseWhereStatement::p_condition>, describe_field_t<SgElseWhereStatement,SgBasicBlock*,&SgElseWhereStatement::p_body>, describe_field_t<SgElseWhereStatement,SgElseWhereStatement*,&SgElseWhereStatement::p_elsewhere>>;
14687};
14688template <> struct node_from_variant_t<397> { using type = SgElseWhereStatement; };
14689
14690// Class: ElseifDirectiveStatement
14691template <> struct describe_node_t<SgElseifDirectiveStatement> {
14692 using node = SgElseifDirectiveStatement;
14693 using base = SgC_PreprocessorDirectiveStatement;
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
14703template <> struct describe_node_t<SgEmptyDeclaration> {
14704 using node = SgEmptyDeclaration;
14705 using base = SgDeclarationStatement;
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
14715template <> struct describe_node_t<SgEmptyDirectiveStatement> {
14716 using node = SgEmptyDirectiveStatement;
14717 using base = SgC_PreprocessorDirectiveStatement;
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
14727template <> struct describe_node_t<SgEndfileStatement> {
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
14739template <> struct describe_node_t<SgEndifDirectiveStatement> {
14740 using node = SgEndifDirectiveStatement;
14741 using base = SgC_PreprocessorDirectiveStatement;
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;
14753 using field_type = SgInitializedName*;
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};
14762template <> struct describe_node_t<SgEntryStatement> {
14763 using node = SgEntryStatement;
14764 using base = SgFunctionDeclaration;
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<>;
14769 using fields_t = mp::List<describe_field_t<SgEntryStatement,SgInitializedName*,&SgEntryStatement::p_result_name>>;
14770};
14771template <> struct node_from_variant_t<403> { using type = SgEntryStatement; };
14772
14773// Class: EnumDeclaration
14774template <> struct describe_field_t<SgEnumDeclaration,SgName,&SgEnumDeclaration::p_name> {
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};
14785template <> struct describe_field_t<SgEnumDeclaration,bool,&SgEnumDeclaration::p_embedded> {
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};
14796template <> struct describe_field_t<SgEnumDeclaration,SgEnumType*,&SgEnumDeclaration::p_type> {
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};
14829template <> struct describe_field_t<SgEnumDeclaration,SgScopeStatement*,&SgEnumDeclaration::p_scope> {
14830 using parent = SgEnumDeclaration;
14831 using field_type = SgScopeStatement*;
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;
14931 using field_type = SgInitializedName*;
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};
14940template <> struct describe_node_t<SgEnumFieldSymbol> {
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<>;
14947 using fields_t = mp::List<describe_field_t<SgEnumFieldSymbol,SgInitializedName*,&SgEnumFieldSymbol::p_declaration>>;
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;
14954 using field_type = SgEnumDeclaration*;
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<>;
14970 using fields_t = mp::List<describe_field_t<SgEnumSymbol,SgEnumDeclaration*,&SgEnumSymbol::p_declaration>>;
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;
15000 using field_type = SgEnumDeclaration*;
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> {
15089 using parent = SgEquivalenceStatement;
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};
15099template <> struct describe_node_t<SgEquivalenceStatement> {
15100 using node = SgEquivalenceStatement;
15101 using base = SgDeclarationStatement;
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<>;
15106 using fields_t = mp::List<describe_field_t<SgEquivalenceStatement,SgExprListExp*,&SgEquivalenceStatement::p_equivalence_set_list>>;
15107};
15108template <> struct node_from_variant_t<410> { using type = SgEquivalenceStatement; };
15109
15110// Class: ErrorDirectiveStatement
15111template <> struct describe_node_t<SgErrorDirectiveStatement> {
15112 using node = SgErrorDirectiveStatement;
15113 using base = SgC_PreprocessorDirectiveStatement;
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
15123template <> struct describe_field_t<SgExecStatement,SgExpression*,&SgExecStatement::p_executable> {
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};
15134template <> struct describe_field_t<SgExecStatement,SgExpression*,&SgExecStatement::p_globals> {
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};
15145template <> struct describe_field_t<SgExecStatement,SgExpression*,&SgExecStatement::p_locals> {
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};
15156template <> struct describe_node_t<SgExecStatement> {
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<>;
15163 using fields_t = mp::List<describe_field_t<SgExecStatement,SgExpression*,&SgExecStatement::p_executable>, describe_field_t<SgExecStatement,SgExpression*,&SgExecStatement::p_globals>, describe_field_t<SgExecStatement,SgExpression*,&SgExecStatement::p_locals>>;
15164};
15165template <> struct node_from_variant_t<412> { using type = SgExecStatement; };
15166
15167// Class: ExponentiationOp
15168template <> struct describe_node_t<SgExponentiationOp> {
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
15180template <> struct describe_node_t<SgExponentiationAssignOp> {
15181 using node = SgExponentiationAssignOp;
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};
15209 using subclasses_t = mp::List<SgListExp, SgTupleExp, SgMatrixExp>;
15210 using fields_t = mp::List<describe_field_t<SgExprListExp,SgExpressionPtrList,&SgExprListExp::p_expressions>>;
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};
15226template <> struct describe_node_t<SgExprStatement> {
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<>;
15233 using fields_t = mp::List<describe_field_t<SgExprStatement,SgExpression*,&SgExprStatement::p_expression>>;
15234};
15235template <> struct node_from_variant_t<416> { using type = SgExprStatement; };
15236
15237// Class: Expression
15238template <> struct describe_field_t<SgExpression,bool,&SgExpression::p_need_paren> {
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};
15249template <> struct describe_field_t<SgExpression,bool,&SgExpression::p_lvalue> {
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};
15288 using subclasses_t = mp::List<SgUnaryOp, SgBinaryOp, SgExprListExp, SgValueExp, SgCallExpression, SgUpcLocalsizeofExpression, SgUpcBlocksizeofExpression, SgUpcElemsizeofExpression, SgJavaInstanceOfOp, SgSuperExp, SgTypeIdOp, SgConditionalExp, SgNewExp, SgDeleteExp, SgThisExp, SgRefExp, SgInitializer, SgVarArgStartOp, SgVarArgOp, SgVarArgEndOp, SgVarArgCopyOp, SgVarArgStartOneOperandOp, SgNullExpression, SgVariantExpression, SgSubscriptExpression, SgColonShapeExp, SgAsteriskShapeExp, SgImpliedDo, SgIOItemExpression, SgActualArgumentExpression, SgStatementExpression, SgAsmOp, SgCudaKernelExecConfig, SgUnknownArrayOrFunctionReference, SgPseudoDestructorRefExp, SgCAFCoExpression, SgSizeOfOp, SgLambdaRefExp, SgDictionaryExp, SgKeyDatumPair, SgReferenceExp, SgComprehension, SgListComprehension, SgSetComprehension, SgDictionaryComprehension, SgNaryOp, SgStringConversion, SgYieldExpression, SgAlignOfOp, SgRangeExp, SgMagicColonExp, SgTypeTraitBuiltinOperator, SgCompoundLiteralExp, SgJavaAnnotation, SgJavaTypeExpression, SgTypeExpression, SgClassExp, SgFunctionParameterRefExp, SgLambdaExp, SgHereExp, SgAtExp, SgFinishExp, SgNoexceptOp, SgAdaTaskRefExp, SgAdaProtectedRefExp, SgFoldExpression, SgAwaitExpression, SgChooseExpression, SgAdaAttributeExp, SgJovialTablePresetExp, SgJovialPresetPositionExp, SgAdaOthersExp, SgAdaRenamingRefExp, SgAdaUnitRefExp>;
15289 using fields_t = mp::List<describe_field_t<SgExpression,bool,&SgExpression::p_need_paren>, describe_field_t<SgExpression,bool,&SgExpression::p_lvalue>, describe_field_t<SgExpression,bool,&SgExpression::p_global_qualified_name>, describe_field_t<SgExpression,Sg_File_Info*,&SgExpression::p_operatorPosition>>;
15290};
15291template <> struct node_from_variant_t<417> { using type = SgExpression; };
15292
15293// Class: ExpressionRoot
15294template <> struct describe_node_t<SgExpressionRoot> {
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};
15317template <> struct describe_field_t<SgFile,SgStringList,&SgFile::p_originalCommandLineArgumentList> {
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;
15528 using field_type = SgFile::outputFormatOption_enum;
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;
15539 using field_type = SgFile::outputFormatOption_enum;
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;
15550 using field_type = SgFile::outputFormatOption_enum;
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;
15847 using field_type = SgFile::languageOption_enum;
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;
15858 using field_type = SgFile::languageOption_enum;
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};
15955template <> struct describe_field_t<SgFile,bool,&SgFile::p_no_implicit_templates> {
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};
15966template <> struct describe_field_t<SgFile,bool,&SgFile::p_no_implicit_inline_templates> {
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};
16021template <> struct describe_field_t<SgFile,ROSEAttributesListContainerPtr,&SgFile::p_preprocessorDirectivesAndCommentsList> {
16022 using parent = SgFile;
16023 using field_type = ROSEAttributesListContainerPtr;
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;
16034 using field_type = AstAttributeMechanism*;
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};
16720 using subclasses_t = mp::List<SgSourceFile, SgUnknownFile, SgBinaryComposite>;
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;
16739 using field_type = AstAttributeMechanism*;
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<>;
16755 using fields_t = mp::List<describe_field_t<SgFileList,SgFilePtrList,&SgFileList::p_listOfFiles>, describe_field_t<SgFileList,AstAttributeMechanism*,&SgFileList::p_attributeMechanism>>;
16756};
16757template <> struct node_from_variant_t<420> { using type = SgFileList; };
16758
16759// Class: FloatVal
16760template <> struct describe_field_t<SgFloatVal,float,&SgFloatVal::p_value> {
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<>;
16789 using fields_t = mp::List<describe_field_t<SgFloatVal,float,&SgFloatVal::p_value>, describe_field_t<SgFloatVal,std::string,&SgFloatVal::p_valueString>>;
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<>;
16823 using fields_t = mp::List<describe_field_t<SgFloat128Val,long double,&SgFloat128Val::p_value>, describe_field_t<SgFloat128Val,std::string,&SgFloat128Val::p_valueString>>;
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<>;
16857 using fields_t = mp::List<describe_field_t<SgFloat80Val,long double,&SgFloat80Val::p_value>, describe_field_t<SgFloat80Val,std::string,&SgFloat80Val::p_valueString>>;
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};
16895template <> struct describe_node_t<SgFoldExpression> {
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<>;
16902 using fields_t = mp::List<describe_field_t<SgFoldExpression,SgExpression*,&SgFoldExpression::p_operands>, describe_field_t<SgFoldExpression,std::string,&SgFoldExpression::p_operator_token>, describe_field_t<SgFoldExpression,bool,&SgFoldExpression::p_is_left_associative>>;
16903};
16904template <> struct node_from_variant_t<424> { using type = SgFoldExpression; };
16905
16906// Class: FlushStatement
16907template <> struct describe_node_t<SgFlushStatement> {
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;
16976 using field_type = SgForAllStatement::forall_statement_kind_enum;
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
16997template <> struct describe_field_t<SgForInitStatement,SgStatementPtrList,&SgForInitStatement::p_init_stmt> {
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};
17008template <> struct describe_node_t<SgForInitStatement> {
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<>;
17015 using fields_t = mp::List<describe_field_t<SgForInitStatement,SgStatementPtrList,&SgForInitStatement::p_init_stmt>>;
17016};
17017template <> struct node_from_variant_t<427> { using type = SgForInitStatement; };
17018
17019// Class: ForStatement
17020template <> struct describe_field_t<SgForStatement,SgForInitStatement*,&SgForStatement::p_for_init_stmt> {
17021 using parent = SgForStatement;
17022 using field_type = SgForInitStatement*;
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};
17053template <> struct describe_field_t<SgForStatement,SgStatement*,&SgForStatement::p_loop_body> {
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};
17064template <> struct describe_field_t<SgForStatement,SgStatement*,&SgForStatement::p_else_body> {
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;
17122 using field_type = SgFormatItemList*;
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<>;
17138 using fields_t = mp::List<describe_field_t<SgFormatItem,int,&SgFormatItem::p_repeat_specification>, describe_field_t<SgFormatItem,SgExpression*,&SgFormatItem::p_data>, describe_field_t<SgFormatItem,SgFormatItemList*,&SgFormatItem::p_format_item_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};
17154template <> struct describe_node_t<SgFormatItemList> {
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<>;
17161 using fields_t = mp::List<describe_field_t<SgFormatItemList,SgFormatItemPtrList,&SgFormatItemList::p_format_item_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;
17168 using field_type = SgFormatItemList*;
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};
17177template <> struct describe_node_t<SgFormatStatement> {
17178 using node = SgFormatStatement;
17179 using base = SgDeclarationStatement;
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<>;
17184 using fields_t = mp::List<describe_field_t<SgFormatStatement,SgFormatItemList*,&SgFormatStatement::p_format_item_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> {
17290 using parent = SgFortranIncludeLine;
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};
17300template <> struct describe_node_t<SgFortranIncludeLine> {
17301 using node = SgFortranIncludeLine;
17302 using base = SgDeclarationStatement;
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<>;
17307 using fields_t = mp::List<describe_field_t<SgFortranIncludeLine,std::string,&SgFortranIncludeLine::p_filename>>;
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> {
17313 using parent = SgFortranNonblockedDo;
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};
17323template <> struct describe_node_t<SgFortranNonblockedDo> {
17324 using node = SgFortranNonblockedDo;
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<>;
17330 using fields_t = mp::List<describe_field_t<SgFortranNonblockedDo,SgStatement*,&SgFortranNonblockedDo::p_end_statement>>;
17331};
17332template <> struct node_from_variant_t<434> { using type = SgFortranNonblockedDo; };
17333
17334// Class: FuncDecl_attr
17335template <> struct describe_node_t<SgFuncDecl_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};
17369template <> struct describe_node_t<SgFunctionCallExp> {
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};
17375 using subclasses_t = mp::List<SgCudaKernelCallExp>;
17376 using fields_t = mp::List<describe_field_t<SgFunctionCallExp,bool,&SgFunctionCallExp::p_uses_operator_syntax>, describe_field_t<SgFunctionCallExp,bool,&SgFunctionCallExp::p_usesObjectCallSyntax>>;
17377};
17378template <> struct node_from_variant_t<436> { using type = SgFunctionCallExp; };
17379
17380// Class: FunctionDeclaration
17381template <> struct describe_field_t<SgFunctionDeclaration,SgName,&SgFunctionDeclaration::p_name> {
17382 using parent = SgFunctionDeclaration;
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> {
17393 using parent = SgFunctionDeclaration;
17394 using field_type = SgFunctionParameterList*;
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};
17403template <> struct describe_field_t<SgFunctionDeclaration,SgFunctionModifier,&SgFunctionDeclaration::p_functionModifier> {
17404 using parent = SgFunctionDeclaration;
17405 using field_type = SgFunctionModifier;
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};
17414template <> struct describe_field_t<SgFunctionDeclaration,SgSpecialFunctionModifier,&SgFunctionDeclaration::p_specialFunctionModifier> {
17415 using parent = SgFunctionDeclaration;
17416 using field_type = SgSpecialFunctionModifier;
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> {
17426 using parent = SgFunctionDeclaration;
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> {
17437 using parent = SgFunctionDeclaration;
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> {
17448 using parent = SgFunctionDeclaration;
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};
17458template <> struct describe_field_t<SgFunctionDeclaration,SgExprListExp*,&SgFunctionDeclaration::p_decoratorList> {
17459 using parent = SgFunctionDeclaration;
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> {
17470 using parent = SgFunctionDeclaration;
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> {
17481 using parent = SgFunctionDeclaration;
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};
17491template <> struct describe_field_t<SgFunctionDeclaration,SgFunctionType*,&SgFunctionDeclaration::p_type> {
17492 using parent = SgFunctionDeclaration;
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};
17502template <> struct describe_field_t<SgFunctionDeclaration,SgFunctionDefinition*,&SgFunctionDeclaration::p_definition> {
17503 using parent = SgFunctionDeclaration;
17504 using field_type = SgFunctionDefinition*;
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};
17513template <> struct describe_field_t<SgFunctionDeclaration,bool,&SgFunctionDeclaration::p_oldStyleDefinition> {
17514 using parent = SgFunctionDeclaration;
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> {
17525 using parent = SgFunctionDeclaration;
17526 using field_type = SgScopeStatement*;
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> {
17536 using parent = SgFunctionDeclaration;
17537 using field_type = SgDeclarationStatement::template_specialization_enum;
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> {
17547 using parent = SgFunctionDeclaration;
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> {
17558 using parent = SgFunctionDeclaration;
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> {
17569 using parent = SgFunctionDeclaration;
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> {
17580 using parent = SgFunctionDeclaration;
17581 using field_type = SgDeclarationStatement::gnu_extension_visability_attribute_enum;
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> {
17591 using parent = SgFunctionDeclaration;
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> {
17602 using parent = SgFunctionDeclaration;
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> {
17613 using parent = SgFunctionDeclaration;
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> {
17624 using parent = SgFunctionDeclaration;
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> {
17635 using parent = SgFunctionDeclaration;
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> {
17646 using parent = SgFunctionDeclaration;
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> {
17657 using parent = SgFunctionDeclaration;
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> {
17668 using parent = SgFunctionDeclaration;
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> {
17679 using parent = SgFunctionDeclaration;
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> {
17690 using parent = SgFunctionDeclaration;
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> {
17701 using parent = SgFunctionDeclaration;
17702 using field_type = SgFunctionParameterList*;
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> {
17712 using parent = SgFunctionDeclaration;
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> {
17723 using parent = SgFunctionDeclaration;
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> {
17734 using parent = SgFunctionDeclaration;
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> {
17745 using parent = SgFunctionDeclaration;
17746 using field_type = SgFunctionParameterScope*;
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> {
17756 using parent = SgFunctionDeclaration;
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> {
17767 using parent = SgFunctionDeclaration;
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};
17777template <> struct describe_node_t<SgFunctionDeclaration> {
17778 using node = SgFunctionDeclaration;
17779 using base = SgDeclarationStatement;
17780 static constexpr char const * const name{"FunctionDeclaration"};
17781 static constexpr unsigned long variant{437};
17782 static constexpr bool concrete{true};
17783 using subclasses_t = mp::List<SgTemplateFunctionDeclaration, SgMemberFunctionDeclaration, SgTemplateInstantiationFunctionDecl, SgProgramHeaderStatement, SgProcedureHeaderStatement, SgEntryStatement, SgAdaEntryDecl, SgAdaFunctionRenamingDecl>;
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
17789template <> struct describe_field_t<SgFunctionDefinition,SgBasicBlock*,&SgFunctionDefinition::p_body> {
17790 using parent = SgFunctionDefinition;
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> {
17801 using parent = SgFunctionDefinition;
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};
17811template <> struct describe_node_t<SgFunctionDefinition> {
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};
17817 using subclasses_t = mp::List<SgTemplateFunctionDefinition>;
17818 using fields_t = mp::List<describe_field_t<SgFunctionDefinition,SgBasicBlock*,&SgFunctionDefinition::p_body>, describe_field_t<SgFunctionDefinition,std::map<SgNode*,int>,&SgFunctionDefinition::p_scope_number_list>>;
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> {
17824 using parent = SgFunctionParameterScope;
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};
17834template <> struct describe_node_t<SgFunctionParameterScope> {
17835 using node = SgFunctionParameterScope;
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<>;
17841 using fields_t = mp::List<describe_field_t<SgFunctionParameterScope,SgDeclarationStatementPtrList,&SgFunctionParameterScope::p_declarations>>;
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;
17903 using field_type = SgFunctionModifier::opencl_work_group_size_t;
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> {
17925 using parent = SgFunctionParameterList;
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};
17935template <> struct describe_node_t<SgFunctionParameterList> {
17936 using node = SgFunctionParameterList;
17937 using base = SgDeclarationStatement;
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<>;
17942 using fields_t = mp::List<describe_field_t<SgFunctionParameterList,SgInitializedNamePtrList,&SgFunctionParameterList::p_args>>;
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> {
17948 using parent = SgFunctionParameterRefExp;
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> {
17959 using parent = SgFunctionParameterRefExp;
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> {
17970 using parent = SgFunctionParameterRefExp;
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> {
17981 using parent = SgFunctionParameterRefExp;
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> {
18004 using parent = SgFunctionParameterTypeList;
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};
18014template <> struct describe_node_t<SgFunctionParameterTypeList> {
18015 using node = SgFunctionParameterTypeList;
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<>;
18021 using fields_t = mp::List<describe_field_t<SgFunctionParameterTypeList,SgTypePtrList,&SgFunctionParameterTypeList::p_arguments>>;
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;
18028 using field_type = SgFunctionSymbol*;
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;
18106 using field_type = SgFunctionDeclaration*;
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};
18115template <> struct describe_node_t<SgFunctionSymbol> {
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};
18121 using subclasses_t = mp::List<SgMemberFunctionSymbol, SgTemplateFunctionSymbol, SgRenameSymbol, SgAdaInheritedFunctionSymbol>;
18122 using fields_t = mp::List<describe_field_t<SgFunctionSymbol,SgFunctionDeclaration*,&SgFunctionSymbol::p_declaration>>;
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;
18162 using field_type = SgFunctionParameterTypeList*;
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> {
18184 using parent = SgFunctionTypeSymbol;
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> {
18195 using parent = SgFunctionTypeSymbol;
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};
18205template <> struct describe_node_t<SgFunctionTypeSymbol> {
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<>;
18212 using fields_t = mp::List<describe_field_t<SgFunctionTypeSymbol,SgName,&SgFunctionTypeSymbol::p_name>, describe_field_t<SgFunctionTypeSymbol,SgType*,&SgFunctionTypeSymbol::p_type>>;
18213};
18214template <> struct node_from_variant_t<447> { using type = SgFunctionTypeSymbol; };
18215
18216// Class: FunctionTypeTable
18217template <> struct describe_field_t<SgFunctionTypeTable,SgSymbolTable*,&SgFunctionTypeTable::p_function_type_table> {
18218 using parent = SgFunctionTypeTable;
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};
18228template <> struct describe_node_t<SgFunctionTypeTable> {
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<>;
18235 using fields_t = mp::List<describe_field_t<SgFunctionTypeTable,SgSymbolTable*,&SgFunctionTypeTable::p_function_type_table>>;
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<>;
18258 using fields_t = mp::List<describe_field_t<SgTypeTable,SgSymbolTable*,&SgTypeTable::p_type_table>>;
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<>;
18281 using fields_t = mp::List<describe_field_t<SgGlobal,SgDeclarationStatementPtrList,&SgGlobal::p_declarations>>;
18282};
18283template <> struct node_from_variant_t<450> { using type = SgGlobal; };
18284
18285// Class: GotoStatement
18286template <> struct describe_field_t<SgGotoStatement,SgLabelStatement*,&SgGotoStatement::p_label> {
18287 using parent = SgGotoStatement;
18288 using field_type = SgLabelStatement*;
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};
18319template <> struct describe_node_t<SgGotoStatement> {
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<>;
18326 using fields_t = mp::List<describe_field_t<SgGotoStatement,SgLabelStatement*,&SgGotoStatement::p_label>, describe_field_t<SgGotoStatement,SgLabelRefExp*,&SgGotoStatement::p_label_expression>, describe_field_t<SgGotoStatement,SgExpression*,&SgGotoStatement::p_selector_expression>>;
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;
18344 using field_type = rose_graph_integer_node_hash_map;
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;
18355 using field_type = rose_graph_integer_edge_hash_map;
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;
18366 using field_type = rose_graph_integerpair_edge_hash_multimap;
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;
18377 using field_type = rose_graph_string_integer_hash_multimap;
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;
18388 using field_type = rose_graph_string_integer_hash_multimap;
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;
18399 using field_type = rose_graph_integer_edge_hash_multimap;
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;
18443 using field_type = AstAttributeMechanism*;
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;
18521 using field_type = AstAttributeMechanism*;
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
18553template <> struct describe_node_t<SgGraphEdgeList> {
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;
18600 using field_type = AstAttributeMechanism*;
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<>;
18627 using fields_t = mp::List<describe_field_t<SgGraphNode,std::string,&SgGraphNode::p_name>, describe_field_t<SgGraphNode,SgNode*,&SgGraphNode::p_SgNode>, describe_field_t<SgGraphNode,int,&SgGraphNode::p_index>, describe_field_t<SgGraphNode,AstAttributeMechanism*,&SgGraphNode::p_attributeMechanism>, describe_field_t<SgGraphNode,std::map<int, std::string>,&SgGraphNode::p_properties>>;
18628};
18629template <> struct node_from_variant_t<455> { using type = SgGraphNode; };
18630
18631// Class: GraphNodeList
18632template <> struct describe_node_t<SgGraphNodeList> {
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
18644template <> struct describe_node_t<SgGreaterOrEqualOp> {
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
18656template <> struct describe_node_t<SgGreaterThanOp> {
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};
18690template <> struct describe_node_t<SgIOItemExpression> {
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<>;
18697 using fields_t = mp::List<describe_field_t<SgIOItemExpression,SgName,&SgIOItemExpression::p_name>, describe_field_t<SgIOItemExpression,SgExpression*,&SgIOItemExpression::p_io_item>>;
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;
18704 using field_type = SgIOStatement::io_statement_enum;
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
18780template <> struct describe_node_t<SgIdentDirectiveStatement> {
18781 using node = SgIdentDirectiveStatement;
18782 using base = SgC_PreprocessorDirectiveStatement;
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
18792template <> struct describe_node_t<SgIfDirectiveStatement> {
18793 using node = SgIfDirectiveStatement;
18794 using base = SgC_PreprocessorDirectiveStatement;
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
18804template <> struct describe_field_t<SgIfStmt,SgStatement*,&SgIfStmt::p_conditional> {
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};
18815template <> struct describe_field_t<SgIfStmt,SgStatement*,&SgIfStmt::p_true_body> {
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};
18826template <> struct describe_field_t<SgIfStmt,SgStatement*,&SgIfStmt::p_false_body> {
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
18948template <> struct describe_node_t<SgIfdefDirectiveStatement> {
18949 using node = SgIfdefDirectiveStatement;
18950 using base = SgC_PreprocessorDirectiveStatement;
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
18960template <> struct describe_node_t<SgIfndefDirectiveStatement> {
18961 using node = SgIfndefDirectiveStatement;
18962 using base = SgC_PreprocessorDirectiveStatement;
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> {
18973 using parent = SgImageControlStatement;
18974 using field_type = SgImageControlStatement::image_control_statement_enum;
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> {
18984 using parent = SgImageControlStatement;
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> {
18995 using parent = SgImageControlStatement;
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> {
19006 using parent = SgImageControlStatement;
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> {
19041 using parent = SgImplicitStatement;
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> {
19052 using parent = SgImplicitStatement;
19053 using field_type = SgImplicitStatement::implicit_spec_enum;
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> {
19063 using parent = SgImplicitStatement;
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;
19131 using field_type = SgScopeStatement*;
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};
19163template <> struct describe_node_t<SgImportStatement> {
19164 using node = SgImportStatement;
19165 using base = SgDeclarationStatement;
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<>;
19170 using fields_t = mp::List<describe_field_t<SgImportStatement,SgExpressionPtrList,&SgImportStatement::p_import_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> {
19176 using parent = SgIncidenceDirectedGraph;
19177 using field_type = rose_graph_integer_edge_hash_multimap;
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> {
19187 using parent = SgIncidenceDirectedGraph;
19188 using field_type = rose_graph_integer_edge_hash_multimap;
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
19209template <> struct describe_node_t<SgIncidenceUndirectedGraph> {
19210 using node = SgIncidenceUndirectedGraph;
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> {
19222 using parent = SgIncludeDirectiveStatement;
19223 using field_type = SgHeaderFileBody*;
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> {
19233 using parent = SgIncludeDirectiveStatement;
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> {
19244 using parent = SgIncludeDirectiveStatement;
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
19575template <> struct describe_node_t<SgIncludeNextDirectiveStatement> {
19576 using node = SgIncludeNextDirectiveStatement;
19577 using base = SgC_PreprocessorDirectiveStatement;
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
19587template <> struct describe_field_t<SgInitializedName,SgName,&SgInitializedName::p_name> {
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};
19609template <> struct describe_field_t<SgInitializedName,SgType*,&SgInitializedName::p_typeptr> {
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};
19620template <> struct describe_field_t<SgInitializedName,SgInitializer*,&SgInitializedName::p_initptr> {
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};
19631template <> struct describe_field_t<SgInitializedName,SgInitializedName*,&SgInitializedName::p_prev_decl_item> {
19632 using parent = SgInitializedName;
19633 using field_type = 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};
19642template <> struct describe_field_t<SgInitializedName,bool,&SgInitializedName::p_is_initializer> {
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};
19653template <> struct describe_field_t<SgInitializedName,SgDeclarationStatement*,&SgInitializedName::p_declptr> {
19654 using parent = SgInitializedName;
19655 using field_type = SgDeclarationStatement*;
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};
19664template <> struct describe_field_t<SgInitializedName,SgStorageModifier*,&SgInitializedName::p_storageModifier> {
19665 using parent = SgInitializedName;
19666 using field_type = SgStorageModifier*;
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};
19675template <> struct describe_field_t<SgInitializedName,SgScopeStatement*,&SgInitializedName::p_scope> {
19676 using parent = SgInitializedName;
19677 using field_type = SgScopeStatement*;
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};
19686template <> struct describe_field_t<SgInitializedName,SgInitializedName::preinitialization_enum,&SgInitializedName::p_preinitialization> {
19687 using parent = SgInitializedName;
19688 using field_type = SgInitializedName::preinitialization_enum;
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};
19708template <> struct describe_field_t<SgInitializedName,SgInitializedName::asm_register_name_enum,&SgInitializedName::p_register_name_code> {
19709 using parent = SgInitializedName;
19710 using field_type = SgInitializedName::asm_register_name_enum;
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;
19853 using field_type = SgDeclarationModifier::gnu_declaration_visability_enum;
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};
20060template <> struct describe_node_t<SgInitializedName> {
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
20072template <> struct describe_field_t<SgInitializer,bool,&SgInitializer::p_is_explicit_cast> {
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};
20414template <> struct describe_node_t<SgInquireStatement> {
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
20426template <> struct describe_node_t<SgIntKeyedBidirectionalGraph> {
20427 using node = SgIntKeyedBidirectionalGraph;
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<>;
20467 using fields_t = mp::List<describe_field_t<SgIntVal,int,&SgIntVal::p_value>, describe_field_t<SgIntVal,std::string,&SgIntVal::p_valueString>>;
20468};
20469template <> struct node_from_variant_t<480> { using type = SgIntVal; };
20470
20471// Class: IntegerDivideOp
20472template <> struct describe_node_t<SgIntegerDivideOp> {
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
20484template <> struct describe_node_t<SgIntegerDivideAssignOp> {
20485 using node = SgIntegerDivideAssignOp;
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;
20509 using field_type = SgFunctionDeclaration*;
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};
20529template <> struct describe_node_t<SgInterfaceBody> {
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<>;
20536 using fields_t = mp::List<describe_field_t<SgInterfaceBody,SgName,&SgInterfaceBody::p_function_name>, describe_field_t<SgInterfaceBody,SgFunctionDeclaration*,&SgInterfaceBody::p_functionDeclaration>, describe_field_t<SgInterfaceBody,bool,&SgInterfaceBody::p_use_function_name>>;
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};
20552template <> struct describe_node_t<SgHeaderFileBody> {
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<>;
20559 using fields_t = mp::List<describe_field_t<SgHeaderFileBody,SgSourceFile*,&SgHeaderFileBody::p_include_file>>;
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};
20586template <> struct describe_node_t<SgHeaderFileReport> {
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<>;
20593 using fields_t = mp::List<describe_field_t<SgHeaderFileReport,SgSourceFile*,&SgHeaderFileReport::p_source_file>, describe_field_t<SgHeaderFileReport,SgSourceFilePtrList,&SgHeaderFileReport::p_include_file_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> {
20599 using parent = SgInterfaceStatement;
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> {
20610 using parent = SgInterfaceStatement;
20611 using field_type = SgInterfaceStatement::generic_spec_enum;
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> {
20621 using parent = SgInterfaceStatement;
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> {
20632 using parent = SgInterfaceStatement;
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;
20656 using field_type = SgInterfaceStatement*;
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};
20665template <> struct describe_node_t<SgInterfaceSymbol> {
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<>;
20672 using fields_t = mp::List<describe_field_t<SgInterfaceSymbol,SgInterfaceStatement*,&SgInterfaceSymbol::p_declaration>>;
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;
20679 using field_type = SgInitializedName*;
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};
20688template <> struct describe_node_t<SgIntrinsicSymbol> {
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<>;
20695 using fields_t = mp::List<describe_field_t<SgIntrinsicSymbol,SgInitializedName*,&SgIntrinsicSymbol::p_declaration>>;
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};
20747template <> struct describe_node_t<SgJovialBitType> {
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<>;
20754 using fields_t = mp::List<describe_field_t<SgJovialBitType,SgExpression*,&SgJovialBitType::p_size>>;
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<>;
20777 using fields_t = mp::List<describe_field_t<SgJovialBitVal,std::string,&SgJovialBitVal::p_valueString>>;
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;
20817 using field_type = SgJovialTableType::StructureSpecifier;
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> {
20850 using parent = SgJovialCompoolStatement;
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};
20860template <> struct describe_node_t<SgJovialCompoolStatement> {
20861 using node = SgJovialCompoolStatement;
20862 using base = SgDeclarationStatement;
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<>;
20867 using fields_t = mp::List<describe_field_t<SgJovialCompoolStatement,SgName,&SgJovialCompoolStatement::p_name>>;
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> {
20873 using parent = SgJovialForThenStatement;
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> {
20884 using parent = SgJovialForThenStatement;
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> {
20895 using parent = SgJovialForThenStatement;
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> {
20906 using parent = SgJovialForThenStatement;
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> {
20917 using parent = SgJovialForThenStatement;
20918 using field_type = SgJovialForThenStatement::loop_statement_type_enum;
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> {
20940 using parent = SgJovialDefineDeclaration;
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};
20950template <> struct describe_node_t<SgJovialDefineDeclaration> {
20951 using node = SgJovialDefineDeclaration;
20952 using base = SgDeclarationStatement;
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<>;
20957 using fields_t = mp::List<describe_field_t<SgJovialDefineDeclaration,std::string,&SgJovialDefineDeclaration::p_define_string>>;
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> {
20963 using parent = SgJovialDirectiveStatement;
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> {
20974 using parent = SgJovialDirectiveStatement;
20975 using field_type = SgJovialDirectiveStatement::directive_types;
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};
20984template <> struct describe_node_t<SgJovialDirectiveStatement> {
20985 using node = SgJovialDirectiveStatement;
20986 using base = SgDeclarationStatement;
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<>;
20991 using fields_t = mp::List<describe_field_t<SgJovialDirectiveStatement,std::string,&SgJovialDirectiveStatement::p_content_string>, describe_field_t<SgJovialDirectiveStatement,SgJovialDirectiveStatement::directive_types,&SgJovialDirectiveStatement::p_directive_type>>;
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> {
20997 using parent = SgJovialOverlayDeclaration;
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> {
21008 using parent = SgJovialOverlayDeclaration;
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};
21018template <> struct describe_node_t<SgJovialOverlayDeclaration> {
21019 using node = SgJovialOverlayDeclaration;
21020 using base = SgDeclarationStatement;
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<>;
21025 using fields_t = mp::List<describe_field_t<SgJovialOverlayDeclaration,SgExpression*,&SgJovialOverlayDeclaration::p_address>, describe_field_t<SgJovialOverlayDeclaration,SgExprListExp*,&SgJovialOverlayDeclaration::p_overlay>>;
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> {
21031 using parent = SgJovialPresetPositionExp;
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> {
21042 using parent = SgJovialPresetPositionExp;
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};
21052template <> struct describe_node_t<SgJovialPresetPositionExp> {
21053 using node = SgJovialPresetPositionExp;
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<>;
21059 using fields_t = mp::List<describe_field_t<SgJovialPresetPositionExp,SgExprListExp*,&SgJovialPresetPositionExp::p_indices>, describe_field_t<SgJovialPresetPositionExp,SgExpression*,&SgJovialPresetPositionExp::p_value>>;
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> {
21065 using parent = SgJovialTablePresetExp;
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};
21075template <> struct describe_node_t<SgJovialTablePresetExp> {
21076 using node = SgJovialTablePresetExp;
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<>;
21082 using fields_t = mp::List<describe_field_t<SgJovialTablePresetExp,SgExprListExp*,&SgJovialTablePresetExp::p_preset_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> {
21088 using parent = SgJovialTableStatement;
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> {
21099 using parent = SgJovialTableStatement;
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> {
21110 using parent = SgJovialTableStatement;
21111 using field_type = SgJovialTableStatement::WordsPerEntry;
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> {
21121 using parent = SgJovialTableStatement;
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> {
21132 using parent = SgJovialTableStatement;
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<>;
21183 using fields_t = mp::List<describe_field_t<SgKeyDatumPair,SgExpression*,&SgKeyDatumPair::p_key>, describe_field_t<SgKeyDatumPair,SgExpression*,&SgKeyDatumPair::p_datum>>;
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> {
21189 using parent = SgCudaKernelExecConfig;
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> {
21200 using parent = SgCudaKernelExecConfig;
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> {
21211 using parent = SgCudaKernelExecConfig;
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> {
21222 using parent = SgCudaKernelExecConfig;
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> {
21245 using parent = SgCudaKernelCallExp;
21246 using field_type = SgCudaKernelExecConfig*;
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};
21255template <> struct describe_node_t<SgCudaKernelCallExp> {
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<>;
21262 using fields_t = mp::List<describe_field_t<SgCudaKernelCallExp,SgCudaKernelExecConfig*,&SgCudaKernelCallExp::p_exec_config>>;
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<>;
21285 using fields_t = mp::List<describe_field_t<SgLabelRefExp,SgLabelSymbol*,&SgLabelRefExp::p_symbol>>;
21286};
21287template <> struct node_from_variant_t<506> { using type = SgLabelRefExp; };
21288
21289// Class: LabelStatement
21290template <> struct describe_field_t<SgLabelStatement,SgName,&SgLabelStatement::p_label> {
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;
21303 using field_type = SgScopeStatement*;
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;
21325 using field_type = SgLabelStatement::label_type_enum;
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> {
21358 using parent = SgJavaLabelStatement;
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> {
21369 using parent = SgJavaLabelStatement;
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};
21379template <> struct describe_node_t<SgJavaLabelStatement> {
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<>;
21386 using fields_t = mp::List<describe_field_t<SgJavaLabelStatement,SgName,&SgJavaLabelStatement::p_label>, describe_field_t<SgJavaLabelStatement,SgStatement*,&SgJavaLabelStatement::p_statement>>;
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;
21393 using field_type = SgLabelStatement*;
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;
21415 using field_type = SgInitializedName*;
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;
21437 using field_type = SgLabelSymbol::label_type_enum;
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;
21460 using field_type = SgJavaLabelStatement*;
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};
21469template <> struct describe_node_t<SgJavaLabelSymbol> {
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<>;
21476 using fields_t = mp::List<describe_field_t<SgJavaLabelSymbol,SgJavaLabelStatement*,&SgJavaLabelSymbol::p_declaration>>;
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> {
21560 using parent = SgLambdaCaptureList;
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};
21570template <> struct describe_node_t<SgLambdaCaptureList> {
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<>;
21577 using fields_t = mp::List<describe_field_t<SgLambdaCaptureList,SgLambdaCapturePtrList,&SgLambdaCaptureList::p_capture_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;
21584 using field_type = SgLambdaCaptureList*;
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;
21595 using field_type = SgClassDeclaration*;
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;
21606 using field_type = SgFunctionDeclaration*;
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
21693template <> struct describe_field_t<SgLambdaRefExp,SgFunctionDeclaration*,&SgLambdaRefExp::p_functionDeclaration> {
21694 using parent = SgLambdaRefExp;
21695 using field_type = SgFunctionDeclaration*;
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<>;
21711 using fields_t = mp::List<describe_field_t<SgLambdaRefExp,SgFunctionDeclaration*,&SgLambdaRefExp::p_functionDeclaration>>;
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
21728template <> struct describe_node_t<SgLessOrEqualOp> {
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
21752template <> struct describe_node_t<SgLineDirectiveStatement> {
21753 using node = SgLineDirectiveStatement;
21754 using base = SgC_PreprocessorDirectiveStatement;
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> {
21765 using parent = SgLinemarkerDirectiveStatement;
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> {
21776 using parent = SgLinemarkerDirectiveStatement;
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> {
21787 using parent = SgLinemarkerDirectiveStatement;
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;
21811 using field_type = SgLinkageModifier::linkage_modifier_enum;
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};
21820template <> struct describe_node_t<SgLinkageModifier> {
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<>;
21827 using fields_t = mp::List<describe_field_t<SgLinkageModifier,SgLinkageModifier::linkage_modifier_enum,&SgLinkageModifier::p_modifier>>;
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> {
21833 using parent = SgListComprehension;
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> {
21844 using parent = SgListComprehension;
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};
21854template <> struct describe_node_t<SgListComprehension> {
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<>;
21861 using fields_t = mp::List<describe_field_t<SgListComprehension,SgExpression*,&SgListComprehension::p_element>, describe_field_t<SgListComprehension,SgExprListExp*,&SgListComprehension::p_generators>>;
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
21878template <> struct describe_field_t<SgLocatedNode,Sg_File_Info*,&SgLocatedNode::p_startOfConstruct> {
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};
21889template <> struct describe_field_t<SgLocatedNode,Sg_File_Info*,&SgLocatedNode::p_endOfConstruct> {
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;
21913 using field_type = AstAttributeMechanism*;
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
21945template <> struct describe_node_t<SgLocatedNodeSupport> {
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};
21951 using subclasses_t = mp::List<SgCommonBlockObject, SgInitializedName, SgInterfaceBody, SgHeaderFileBody, SgRenamePair, SgJavaMemberValuePair, SgOmpClause, SgLambdaCapture, SgLambdaCaptureList, SgAdaTypeConstraint>;
21952 using fields_t = mp::List<>;
21953};
21954template <> struct node_from_variant_t<524> { using type = SgLocatedNodeSupport; };
21955
21956// Class: LongDoubleVal
21957template <> struct describe_field_t<SgLongDoubleVal,long double,&SgLongDoubleVal::p_value> {
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};
21979template <> struct describe_node_t<SgLongDoubleVal> {
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<>;
21986 using fields_t = mp::List<describe_field_t<SgLongDoubleVal,long double,&SgLongDoubleVal::p_value>, describe_field_t<SgLongDoubleVal,std::string,&SgLongDoubleVal::p_valueString>>;
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<>;
22020 using fields_t = mp::List<describe_field_t<SgLongIntVal,long int,&SgLongIntVal::p_value>, describe_field_t<SgLongIntVal,std::string,&SgLongIntVal::p_valueString>>;
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};
22047template <> struct describe_node_t<SgLongLongIntVal> {
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<>;
22054 using fields_t = mp::List<describe_field_t<SgLongLongIntVal,long long int,&SgLongLongIntVal::p_value>, describe_field_t<SgLongLongIntVal,std::string,&SgLongLongIntVal::p_valueString>>;
22055};
22056template <> struct node_from_variant_t<527> { using type = SgLongLongIntVal; };
22057
22058// Class: LshiftAssignOp
22059template <> struct describe_node_t<SgLshiftAssignOp> {
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
22083template <> struct describe_node_t<SgMagicColonExp> {
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> {
22108 using parent = SgMatrixTransposeOp;
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};
22118template <> struct describe_node_t<SgMatrixTransposeOp> {
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<>;
22125 using fields_t = mp::List<describe_field_t<SgMatrixTransposeOp,bool,&SgMatrixTransposeOp::p_is_conjugate>>;
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> {
22131 using parent = SgMatlabForStatement;
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> {
22142 using parent = SgMatlabForStatement;
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> {
22153 using parent = SgMatlabForStatement;
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};
22163template <> struct describe_node_t<SgMatlabForStatement> {
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<>;
22170 using fields_t = mp::List<describe_field_t<SgMatlabForStatement,SgExpression*,&SgMatlabForStatement::p_index>, describe_field_t<SgMatlabForStatement,SgExpression*,&SgMatlabForStatement::p_range>, describe_field_t<SgMatlabForStatement,SgBasicBlock*,&SgMatlabForStatement::p_body>>;
22171};
22172template <> struct node_from_variant_t<533> { using type = SgMatlabForStatement; };
22173
22174// Class: MemberFunctionDeclaration
22175template <> struct describe_field_t<SgMemberFunctionDeclaration,SgCtorInitializerList*,&SgMemberFunctionDeclaration::p_CtorInitializerList> {
22176 using parent = SgMemberFunctionDeclaration;
22177 using field_type = SgCtorInitializerList*;
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> {
22187 using parent = SgMemberFunctionDeclaration;
22188 using field_type = SgDeclarationStatement*;
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
22209template <> struct describe_field_t<SgMemberFunctionRefExp,SgMemberFunctionSymbol*,&SgMemberFunctionRefExp::p_symbol_i> {
22210 using parent = SgMemberFunctionRefExp;
22211 using field_type = SgMemberFunctionSymbol*;
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};
22220template <> struct describe_field_t<SgMemberFunctionRefExp,int,&SgMemberFunctionRefExp::p_virtual_call> {
22221 using parent = SgMemberFunctionRefExp;
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};
22231template <> struct describe_field_t<SgMemberFunctionRefExp,SgFunctionType*,&SgMemberFunctionRefExp::p_function_type> {
22232 using parent = SgMemberFunctionRefExp;
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};
22242template <> struct describe_field_t<SgMemberFunctionRefExp,int,&SgMemberFunctionRefExp::p_need_qualifier> {
22243 using parent = SgMemberFunctionRefExp;
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> {
22254 using parent = SgMemberFunctionRefExp;
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> {
22265 using parent = SgMemberFunctionRefExp;
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> {
22276 using parent = SgMemberFunctionRefExp;
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
22298template <> struct describe_node_t<SgMemberFunctionSymbol> {
22299 using node = SgMemberFunctionSymbol;
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};
22304 using subclasses_t = mp::List<SgTemplateMemberFunctionSymbol>;
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> {
22311 using parent = SgMemberFunctionType;
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> {
22322 using parent = SgMemberFunctionType;
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};
22332template <> struct describe_node_t<SgMemberFunctionType> {
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};
22338 using subclasses_t = mp::List<SgPartialFunctionType>;
22339 using fields_t = mp::List<describe_field_t<SgMemberFunctionType,SgType*,&SgMemberFunctionType::p_class_type>, describe_field_t<SgMemberFunctionType,unsigned int,&SgMemberFunctionType::p_mfunc_specifier>>;
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> {
22357 using parent = SgMicrosoftAttributeDeclaration;
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};
22367template <> struct describe_node_t<SgMicrosoftAttributeDeclaration> {
22368 using node = SgMicrosoftAttributeDeclaration;
22369 using base = SgDeclarationStatement;
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<>;
22374 using fields_t = mp::List<describe_field_t<SgMicrosoftAttributeDeclaration,SgName,&SgMicrosoftAttributeDeclaration::p_attribute_string>>;
22375};
22376template <> struct node_from_variant_t<539> { using type = SgMicrosoftAttributeDeclaration; };
22377
22378// Class: MinusAssignOp
22379template <> struct describe_node_t<SgMinusAssignOp> {
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};
22473template <> struct describe_node_t<SgModifierNodes> {
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<>;
22480 using fields_t = mp::List<describe_field_t<SgModifierNodes,SgModifierTypePtrVector,&SgModifierNodes::p_nodes>, describe_field_t<SgModifierNodes,SgModifierNodes*,&SgModifierNodes::p_next>>;
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<>;
22525 using fields_t = mp::List<describe_field_t<SgModifierType,SgType*,&SgModifierType::p_base_type>, describe_field_t<SgModifierType,SgTypeModifier,&SgModifierType::p_typeModifier>, describe_field_t<SgModifierType,char*,&SgModifierType::p_frontend_type_reference>>;
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};
22541template <> struct describe_node_t<SgModuleStatement> {
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<>;
22548 using fields_t = mp::List<describe_field_t<SgModuleStatement,SgLabelRefExp*,&SgModuleStatement::p_end_numeric_label>>;
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;
22555 using field_type = SgModuleStatement*;
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<>;
22571 using fields_t = mp::List<describe_field_t<SgModuleSymbol,SgModuleStatement*,&SgModuleSymbol::p_declaration>>;
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<>;
22618 using fields_t = mp::List<describe_field_t<SgName,std::string,&SgName::p_char>>;
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<>;
22652 using fields_t = mp::List<describe_field_t<SgNameGroup,std::string,&SgNameGroup::p_group_name>, describe_field_t<SgNameGroup,SgStringList,&SgNameGroup::p_name_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;
22659 using field_type = SgDeclarationStatement*;
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> {
22703 using parent = SgNamelistStatement;
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};
22713template <> struct describe_node_t<SgNamelistStatement> {
22714 using node = SgNamelistStatement;
22715 using base = SgDeclarationStatement;
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<>;
22720 using fields_t = mp::List<describe_field_t<SgNamelistStatement,SgNameGroupPtrList,&SgNamelistStatement::p_group_list>>;
22721};
22722template <> struct node_from_variant_t<555> { using type = SgNamelistStatement; };
22723
22724// Class: NamespaceAliasDeclarationStatement
22725template <> struct describe_field_t<SgNamespaceAliasDeclarationStatement,SgName,&SgNamespaceAliasDeclarationStatement::p_name> {
22726 using parent = SgNamespaceAliasDeclarationStatement;
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};
22736template <> struct describe_field_t<SgNamespaceAliasDeclarationStatement,SgNamespaceDeclarationStatement*,&SgNamespaceAliasDeclarationStatement::p_namespaceDeclaration> {
22737 using parent = SgNamespaceAliasDeclarationStatement;
22738 using field_type = SgNamespaceDeclarationStatement*;
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};
22743 static constexpr auto mbr_ptr{&SgNamespaceAliasDeclarationStatement::p_namespaceDeclaration};
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> {
22748 using parent = SgNamespaceAliasDeclarationStatement;
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> {
22759 using parent = SgNamespaceAliasDeclarationStatement;
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> {
22770 using parent = SgNamespaceAliasDeclarationStatement;
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> {
22781 using parent = SgNamespaceAliasDeclarationStatement;
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> {
22792 using parent = SgNamespaceAliasDeclarationStatement;
22793 using field_type = SgNamespaceAliasDeclarationStatement*;
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
22814template <> struct describe_field_t<SgNamespaceDeclarationStatement,SgName,&SgNamespaceDeclarationStatement::p_name> {
22815 using parent = SgNamespaceDeclarationStatement;
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};
22825template <> struct describe_field_t<SgNamespaceDeclarationStatement,SgNamespaceDefinitionStatement*,&SgNamespaceDeclarationStatement::p_definition> {
22826 using parent = SgNamespaceDeclarationStatement;
22827 using field_type = SgNamespaceDefinitionStatement*;
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};
22836template <> struct describe_field_t<SgNamespaceDeclarationStatement,bool,&SgNamespaceDeclarationStatement::p_isUnnamedNamespace> {
22837 using parent = SgNamespaceDeclarationStatement;
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> {
22848 using parent = SgNamespaceDeclarationStatement;
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
22870template <> struct describe_field_t<SgNamespaceDefinitionStatement,SgDeclarationStatementPtrList,&SgNamespaceDefinitionStatement::p_declarations> {
22871 using parent = SgNamespaceDefinitionStatement;
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};
22881template <> struct describe_field_t<SgNamespaceDefinitionStatement,SgNamespaceDeclarationStatement*,&SgNamespaceDefinitionStatement::p_namespaceDeclaration> {
22882 using parent = SgNamespaceDefinitionStatement;
22883 using field_type = SgNamespaceDeclarationStatement*;
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> {
22893 using parent = SgNamespaceDefinitionStatement;
22894 using field_type = SgNamespaceDefinitionStatement*;
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> {
22904 using parent = SgNamespaceDefinitionStatement;
22905 using field_type = SgNamespaceDefinitionStatement*;
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> {
22915 using parent = SgNamespaceDefinitionStatement;
22916 using field_type = SgNamespaceDefinitionStatement*;
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> {
22926 using parent = SgNamespaceDefinitionStatement;
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;
22961 using field_type = SgNamespaceDeclarationStatement*;
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;
22972 using field_type = SgNamespaceAliasDeclarationStatement*;
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};
23032 using subclasses_t = mp::List<SgNaryBooleanOp, SgNaryComparisonOp>;
23033 using fields_t = mp::List<describe_field_t<SgNaryOp,SgExpressionPtrList,&SgNaryOp::p_operands>, describe_field_t<SgNaryOp,VariantTList,&SgNaryOp::p_operators>>;
23034};
23035template <> struct node_from_variant_t<560> { using type = SgNaryOp; };
23036
23037// Class: NaryBooleanOp
23038template <> struct describe_node_t<SgNaryBooleanOp> {
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
23050template <> struct describe_node_t<SgNaryComparisonOp> {
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};
23073template <> struct describe_field_t<SgNewExp,SgExprListExp*,&SgNewExp::p_placement_args> {
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};
23084template <> struct describe_field_t<SgNewExp,SgConstructorInitializer*,&SgNewExp::p_constructor_args> {
23085 using parent = SgNewExp;
23086 using field_type = SgConstructorInitializer*;
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};
23095template <> struct describe_field_t<SgNewExp,SgExpression*,&SgNewExp::p_builtin_args> {
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};
23106template <> struct describe_field_t<SgNewExp,short,&SgNewExp::p_need_global_specifier> {
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;
23119 using field_type = SgFunctionDeclaration*;
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
23206template <> struct describe_field_t<SgNode,SgNode*,&SgNode::p_parent> {
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};
23217template <> struct describe_field_t<SgNode,bool,&SgNode::p_isModified> {
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};
23239template <> struct describe_field_t<SgNode,SgNode*,&SgNode::p_freepointer> {
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};
23256 using subclasses_t = mp::List<SgSupport, SgType, SgLocatedNode, SgSymbol, SgAsmNode>;
23257 using fields_t = mp::List<describe_field_t<SgNode,SgNode*,&SgNode::p_parent>, describe_field_t<SgNode,bool,&SgNode::p_isModified>, describe_field_t<SgNode,bool,&SgNode::p_containsTransformation>, describe_field_t<SgNode,SgNode*,&SgNode::p_freepointer>>;
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<>;
23280 using fields_t = mp::List<describe_field_t<SgNoexceptOp,SgExpression*,&SgNoexceptOp::p_operand_expr>>;
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
23309template <> struct describe_node_t<SgNonMembershipOp> {
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;
23334 using field_type = SgDeclarationScope*;
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;
23378 using field_type = SgDeclarationStatement*;
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};
23543template <> struct describe_node_t<SgNonrealSymbol> {
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<>;
23550 using fields_t = mp::List<describe_field_t<SgNonrealSymbol,SgNonrealDecl*,&SgNonrealSymbol::p_declaration>>;
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};
23578template <> struct describe_node_t<SgNonrealBaseClass> {
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<>;
23585 using fields_t = mp::List<describe_field_t<SgNonrealBaseClass,SgNonrealDecl*,&SgNonrealBaseClass::p_base_class_nonreal>>;
23586};
23587template <> struct node_from_variant_t<573> { using type = SgNonrealBaseClass; };
23588
23589// Class: NullExpression
23590template <> struct describe_node_t<SgNullExpression> {
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
23602template <> struct describe_node_t<SgNullptrValExp> {
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
23614template <> struct describe_node_t<SgNullStatement> {
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};
23637template <> struct describe_node_t<SgNullifyStatement> {
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<>;
23644 using fields_t = mp::List<describe_field_t<SgNullifyStatement,SgExprListExp*,&SgNullifyStatement::p_pointer_list>>;
23645};
23646template <> struct node_from_variant_t<577> { using type = SgNullifyStatement; };
23647
23648// Class: OmpAtomicStatement
23649template <> struct describe_node_t<SgOmpAtomicStatement> {
23650 using node = SgOmpAtomicStatement;
23651 using base = SgOmpClauseBodyStatement;
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
23661template <> struct describe_node_t<SgOmpBarrierStatement> {
23662 using node = SgOmpBarrierStatement;
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> {
23674 using parent = SgOmpCriticalStatement;
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};
23684template <> struct describe_node_t<SgOmpCriticalStatement> {
23685 using node = SgOmpCriticalStatement;
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<>;
23691 using fields_t = mp::List<describe_field_t<SgOmpCriticalStatement,SgName,&SgOmpCriticalStatement::p_name>>;
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> {
23697 using parent = SgOmpClauseBodyStatement;
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};
23730template <> struct describe_node_t<SgOmpBodyStatement> {
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};
23736 using subclasses_t = mp::List<SgOmpMasterStatement, SgOmpOrderedStatement, SgOmpCriticalStatement, SgOmpSectionStatement, SgOmpWorkshareStatement, SgOmpClauseBodyStatement>;
23737 using fields_t = mp::List<describe_field_t<SgOmpBodyStatement,SgStatement*,&SgOmpBodyStatement::p_body>>;
23738};
23739template <> struct node_from_variant_t<582> { using type = SgOmpBodyStatement; };
23740
23741// Class: OmpDoStatement
23742template <> struct describe_node_t<SgOmpDoStatement> {
23743 using node = SgOmpDoStatement;
23744 using base = SgOmpClauseBodyStatement;
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> {
23755 using parent = SgOmpFlushStatement;
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};
23765template <> struct describe_node_t<SgOmpFlushStatement> {
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<>;
23772 using fields_t = mp::List<describe_field_t<SgOmpFlushStatement,SgVarRefExpPtrList,&SgOmpFlushStatement::p_variables>>;
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> {
23778 using parent = SgOmpDeclareSimdStatement;
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};
23788template <> struct describe_node_t<SgOmpDeclareSimdStatement> {
23789 using node = SgOmpDeclareSimdStatement;
23790 using base = SgDeclarationStatement;
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<>;
23795 using fields_t = mp::List<describe_field_t<SgOmpDeclareSimdStatement,SgOmpClausePtrList,&SgOmpDeclareSimdStatement::p_clauses>>;
23796};
23797template <> struct node_from_variant_t<585> { using type = SgOmpDeclareSimdStatement; };
23798
23799// Class: OmpForStatement
23800template <> struct describe_node_t<SgOmpForStatement> {
23801 using node = SgOmpForStatement;
23802 using base = SgOmpClauseBodyStatement;
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
23812template <> struct describe_node_t<SgOmpForSimdStatement> {
23813 using node = SgOmpForSimdStatement;
23814 using base = SgOmpClauseBodyStatement;
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
23824template <> struct describe_node_t<SgOmpMasterStatement> {
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
23836template <> struct describe_node_t<SgOmpOrderedStatement> {
23837 using node = SgOmpOrderedStatement;
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
23848template <> struct describe_node_t<SgOmpParallelStatement> {
23849 using node = SgOmpParallelStatement;
23850 using base = SgOmpClauseBodyStatement;
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
23860template <> struct describe_node_t<SgOmpSectionStatement> {
23861 using node = SgOmpSectionStatement;
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
23872template <> struct describe_node_t<SgOmpSectionsStatement> {
23873 using node = SgOmpSectionsStatement;
23874 using base = SgOmpClauseBodyStatement;
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
23884template <> struct describe_node_t<SgOmpSingleStatement> {
23885 using node = SgOmpSingleStatement;
23886 using base = SgOmpClauseBodyStatement;
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
23896template <> struct describe_node_t<SgOmpTaskStatement> {
23897 using node = SgOmpTaskStatement;
23898 using base = SgOmpClauseBodyStatement;
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
23908template <> struct describe_node_t<SgOmpTaskwaitStatement> {
23909 using node = SgOmpTaskwaitStatement;
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> {
23921 using parent = SgOmpThreadprivateStatement;
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};
23931template <> struct describe_node_t<SgOmpThreadprivateStatement> {
23932 using node = SgOmpThreadprivateStatement;
23933 using base = SgDeclarationStatement;
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<>;
23938 using fields_t = mp::List<describe_field_t<SgOmpThreadprivateStatement,SgVarRefExpPtrList,&SgOmpThreadprivateStatement::p_variables>>;
23939};
23940template <> struct node_from_variant_t<596> { using type = SgOmpThreadprivateStatement; };
23941
23942// Class: OmpWorkshareStatement
23943template <> struct describe_node_t<SgOmpWorkshareStatement> {
23944 using node = SgOmpWorkshareStatement;
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
23955template <> struct describe_node_t<SgOmpTargetStatement> {
23956 using node = SgOmpTargetStatement;
23957 using base = SgOmpClauseBodyStatement;
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
23967template <> struct describe_node_t<SgOmpTargetDataStatement> {
23968 using node = SgOmpTargetDataStatement;
23969 using base = SgOmpClauseBodyStatement;
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
23979template <> struct describe_node_t<SgOmpSimdStatement> {
23980 using node = SgOmpSimdStatement;
23981 using base = SgOmpClauseBodyStatement;
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};
23997 using subclasses_t = mp::List<SgOmpNowaitClause, SgOmpBeginClause, SgOmpEndClause, SgOmpUntiedClause, SgOmpDefaultClause, SgOmpAtomicClause, SgOmpProcBindClause, SgOmpExpressionClause, SgOmpInbranchClause, SgOmpNotinbranchClause, SgOmpVariablesClause, SgOmpScheduleClause, SgOmpMergeableClause>;
23998 using fields_t = mp::List<>;
23999};
24000template <> struct node_from_variant_t<601> { using type = SgOmpClause; };
24001
24002// Class: OmpBeginClause
24003template <> struct describe_node_t<SgOmpBeginClause> {
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
24015template <> struct describe_node_t<SgOmpCollapseClause> {
24016 using node = SgOmpCollapseClause;
24017 using base = SgOmpExpressionClause;
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
24027template <> struct describe_node_t<SgOmpCopyinClause> {
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
24039template <> struct describe_node_t<SgOmpCopyprivateClause> {
24040 using node = SgOmpCopyprivateClause;
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;
24053 using field_type = SgOmpClause::omp_default_option_enum;
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};
24062template <> struct describe_node_t<SgOmpDefaultClause> {
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<>;
24069 using fields_t = mp::List<describe_field_t<SgOmpDefaultClause,SgOmpClause::omp_default_option_enum,&SgOmpDefaultClause::p_data_sharing>>;
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> {
24087 using parent = SgOmpExpressionClause;
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};
24097template <> struct describe_node_t<SgOmpExpressionClause> {
24098 using node = SgOmpExpressionClause;
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};
24103 using subclasses_t = mp::List<SgOmpOrderedClause, SgOmpCollapseClause, SgOmpIfClause, SgOmpNumThreadsClause, SgOmpDeviceClause, SgOmpSafelenClause, SgOmpSimdlenClause, SgOmpFinalClause, SgOmpPriorityClause>;
24104 using fields_t = mp::List<describe_field_t<SgOmpExpressionClause,SgExpression*,&SgOmpExpressionClause::p_expression>>;
24105};
24106template <> struct node_from_variant_t<608> { using type = SgOmpExpressionClause; };
24107
24108// Class: OmpFirstprivateClause
24109template <> struct describe_node_t<SgOmpFirstprivateClause> {
24110 using node = SgOmpFirstprivateClause;
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;
24123 using base = SgOmpExpressionClause;
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
24133template <> struct describe_node_t<SgOmpFinalClause> {
24134 using node = SgOmpFinalClause;
24135 using base = SgOmpExpressionClause;
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
24145template <> struct describe_node_t<SgOmpPriorityClause> {
24146 using node = SgOmpPriorityClause;
24147 using base = SgOmpExpressionClause;
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
24157template <> struct describe_node_t<SgOmpDeviceClause> {
24158 using node = SgOmpDeviceClause;
24159 using base = SgOmpExpressionClause;
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
24169template <> struct describe_node_t<SgOmpLastprivateClause> {
24170 using node = SgOmpLastprivateClause;
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
24181template <> struct describe_node_t<SgOmpNowaitClause> {
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
24193template <> struct describe_node_t<SgOmpNumThreadsClause> {
24194 using node = SgOmpNumThreadsClause;
24195 using base = SgOmpExpressionClause;
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
24205template <> struct describe_node_t<SgOmpOrderedClause> {
24206 using node = SgOmpOrderedClause;
24207 using base = SgOmpExpressionClause;
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
24217template <> struct describe_node_t<SgOmpPrivateClause> {
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> {
24230 using parent = SgOmpReductionClause;
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};
24240template <> struct describe_node_t<SgOmpReductionClause> {
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<>;
24247 using fields_t = mp::List<describe_field_t<SgOmpReductionClause,SgOmpClause::omp_reduction_operator_enum,&SgOmpReductionClause::p_operation>>;
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> {
24253 using parent = SgOmpScheduleClause;
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> {
24264 using parent = SgOmpScheduleClause;
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};
24274template <> struct describe_node_t<SgOmpScheduleClause> {
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<>;
24281 using fields_t = mp::List<describe_field_t<SgOmpScheduleClause,SgOmpClause::omp_schedule_kind_enum,&SgOmpScheduleClause::p_kind>, describe_field_t<SgOmpScheduleClause,SgExpression*,&SgOmpScheduleClause::p_chunk_size>>;
24282};
24283template <> struct node_from_variant_t<620> { using type = SgOmpScheduleClause; };
24284
24285// Class: OmpSharedClause
24286template <> struct describe_node_t<SgOmpSharedClause> {
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
24298template <> struct describe_node_t<SgOmpUntiedClause> {
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
24310template <> struct describe_node_t<SgOmpMergeableClause> {
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> {
24323 using parent = SgOmpVariablesClause;
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<>;
24385 using fields_t = mp::List<describe_field_t<SgOmpMapClause,SgOmpClause::omp_map_operator_enum,&SgOmpMapClause::p_operation>, describe_field_t<SgOmpMapClause,std::map<SgSymbol*, std::vector < std::pair <SgExpression*, SgExpression*> > >,&SgOmpMapClause::p_array_dimensions>, describe_field_t<SgOmpMapClause,std::map<SgSymbol*, std::vector < std::pair <SgOmpClause::omp_map_dist_data_enum, SgExpression*> > >,&SgOmpMapClause::p_dist_data_policies>>;
24386};
24387template <> struct node_from_variant_t<625> { using type = SgOmpMapClause; };
24388
24389// Class: OmpSafelenClause
24390template <> struct describe_node_t<SgOmpSafelenClause> {
24391 using node = SgOmpSafelenClause;
24392 using base = SgOmpExpressionClause;
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
24402template <> struct describe_node_t<SgOmpSimdlenClause> {
24403 using node = SgOmpSimdlenClause;
24404 using base = SgOmpExpressionClause;
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};
24425template <> struct describe_node_t<SgOmpLinearClause> {
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<>;
24432 using fields_t = mp::List<describe_field_t<SgOmpLinearClause,SgExpression*,&SgOmpLinearClause::p_step>>;
24433};
24434template <> struct node_from_variant_t<628> { using type = SgOmpLinearClause; };
24435
24436// Class: OmpUniformClause
24437template <> struct describe_node_t<SgOmpUniformClause> {
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};
24460template <> struct describe_node_t<SgOmpAlignedClause> {
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<>;
24467 using fields_t = mp::List<describe_field_t<SgOmpAlignedClause,SgExpression*,&SgOmpAlignedClause::p_alignment>>;
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> {
24473 using parent = SgOmpProcBindClause;
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};
24483template <> struct describe_node_t<SgOmpProcBindClause> {
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<>;
24490 using fields_t = mp::List<describe_field_t<SgOmpProcBindClause,SgOmpClause::omp_proc_bind_policy_enum,&SgOmpProcBindClause::p_policy>>;
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};
24506template <> struct describe_node_t<SgOmpAtomicClause> {
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<>;
24513 using fields_t = mp::List<describe_field_t<SgOmpAtomicClause,SgOmpClause::omp_atomic_clause_enum,&SgOmpAtomicClause::p_atomicity>>;
24514};
24515template <> struct node_from_variant_t<632> { using type = SgOmpAtomicClause; };
24516
24517// Class: OmpInbranchClause
24518template <> struct describe_node_t<SgOmpInbranchClause> {
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
24530template <> struct describe_node_t<SgOmpNotinbranchClause> {
24531 using node = SgOmpNotinbranchClause;
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};
24564template <> struct describe_node_t<SgOmpDependClause> {
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<>;
24571 using fields_t = mp::List<describe_field_t<SgOmpDependClause,SgOmpClause::omp_dependence_type_enum,&SgOmpDependClause::p_dependence_type>, describe_field_t<SgOmpDependClause,std::map<SgSymbol*, std::vector < std::pair <SgExpression*, SgExpression*> > >,&SgOmpDependClause::p_array_dimensions>>;
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> {
24577 using parent = SgOpenclAccessModeModifier;
24578 using field_type = SgOpenclAccessModeModifier::access_mode_modifier_enum;
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};
24587template <> struct describe_node_t<SgOpenclAccessModeModifier> {
24588 using node = SgOpenclAccessModeModifier;
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<>;
24594 using fields_t = mp::List<describe_field_t<SgOpenclAccessModeModifier,SgOpenclAccessModeModifier::access_mode_modifier_enum,&SgOpenclAccessModeModifier::p_modifier>>;
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
24844template <> struct describe_node_t<SgParameterStatement> {
24845 using node = SgParameterStatement;
24846 using base = SgDeclarationStatement;
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
24856template <> struct describe_node_t<SgPartialFunctionModifierType> {
24857 using node = SgPartialFunctionModifierType;
24858 using base = SgPartialFunctionType;
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
24868template <> struct describe_node_t<SgPartialFunctionType> {
24869 using node = SgPartialFunctionType;
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};
24874 using subclasses_t = mp::List<SgPartialFunctionModifierType>;
24875 using fields_t = mp::List<>;
24876};
24877template <> struct node_from_variant_t<642> { using type = SgPartialFunctionType; };
24878
24879// Class: PassStatement
24880template <> struct describe_node_t<SgPassStatement> {
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
24916template <> struct describe_node_t<SgPntrArrRefExp> {
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
24928template <> struct describe_node_t<SgPointerAssignOp> {
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
24940template <> struct describe_node_t<SgPointerDerefExp> {
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> {
24953 using parent = SgPointerMemberType;
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};
24963template <> struct describe_node_t<SgPointerMemberType> {
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<>;
24970 using fields_t = mp::List<describe_field_t<SgPointerMemberType,SgType*,&SgPointerMemberType::p_class_type>>;
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};
24992 using subclasses_t = mp::List<SgPointerMemberType>;
24993 using fields_t = mp::List<describe_field_t<SgPointerType,SgType*,&SgPointerType::p_base_type>>;
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;
25067 using field_type = AstAttributeMechanism*;
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> {
25089 using parent = SgPragmaDeclaration;
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};
25099template <> struct describe_node_t<SgPragmaDeclaration> {
25100 using node = SgPragmaDeclaration;
25101 using base = SgDeclarationStatement;
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<>;
25106 using fields_t = mp::List<describe_field_t<SgPragmaDeclaration,SgPragma*,&SgPragmaDeclaration::p_pragma>>;
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};
25122template <> struct describe_node_t<SgPrintStatement> {
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<>;
25129 using fields_t = mp::List<describe_field_t<SgPrintStatement,SgExpression*,&SgPrintStatement::p_format>>;
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> {
25135 using parent = SgProcedureHeaderStatement;
25136 using field_type = SgProcedureHeaderStatement::subprogram_kind_enum;
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> {
25146 using parent = SgProcedureHeaderStatement;
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> {
25157 using parent = SgProcedureHeaderStatement;
25158 using field_type = SgInitializedName*;
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> {
25180 using parent = SgProgramHeaderStatement;
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> {
25191 using parent = SgProgramHeaderStatement;
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};
25201template <> struct describe_node_t<SgProgramHeaderStatement> {
25202 using node = SgProgramHeaderStatement;
25203 using base = SgFunctionDeclaration;
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<>;
25208 using fields_t = mp::List<describe_field_t<SgProgramHeaderStatement,bool,&SgProgramHeaderStatement::p_program_statement_explicit>, describe_field_t<SgProgramHeaderStatement,SgLabelRefExp*,&SgProgramHeaderStatement::p_end_numeric_label>>;
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};
25224template <> struct describe_field_t<SgProject,SgStringList,&SgProject::p_originalCommandLineArgumentList> {
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};
25235template <> struct describe_field_t<SgProject,int,&SgProject::p_frontendErrorCode> {
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};
25279template <> struct describe_field_t<SgProject,int,&SgProject::p_backendErrorCode> {
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};
25312template <> struct describe_field_t<SgProject,std::string,&SgProject::p_outputFileName> {
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};
25323template <> struct describe_field_t<SgProject,SgStringList,&SgProject::p_sourceFileNameList> {
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};
25334template <> struct describe_field_t<SgProject,SgStringList,&SgProject::p_objectFileNameList> {
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};
25345template <> struct describe_field_t<SgProject,SgStringList,&SgProject::p_libraryFileList> {
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};
25356template <> struct describe_field_t<SgProject,SgStringList,&SgProject::p_librarySpecifierList> {
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};
25367template <> struct describe_field_t<SgProject,SgStringList,&SgProject::p_libraryDirectorySpecifierList> {
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};
25378template <> struct describe_field_t<SgProject,SgStringList,&SgProject::p_includeDirectorySpecifierList> {
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};
25422template <> struct describe_field_t<SgProject,bool,&SgProject::p_compileOnly> {
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};
25444template <> struct describe_field_t<SgProject,bool,&SgProject::p_prelink> {
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;
25457 using field_type = SgProject::template_instantiation_enum;
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;
25501 using field_type = AstAttributeMechanism*;
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};
25741template <> struct describe_field_t<SgProject,bool,&SgProject::p_openmp_linking> {
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> {
26194 using parent = SgPseudoDestructorRefExp;
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> {
26205 using parent = SgPseudoDestructorRefExp;
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> {
26216 using parent = SgPseudoDestructorRefExp;
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> {
26227 using parent = SgPseudoDestructorRefExp;
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> {
26238 using parent = SgPseudoDestructorRefExp;
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};
26271template <> struct describe_node_t<SgPythonGlobalStmt> {
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<>;
26278 using fields_t = mp::List<describe_field_t<SgPythonGlobalStmt,SgInitializedNamePtrList,&SgPythonGlobalStmt::p_names>>;
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};
26305template <> struct describe_node_t<SgPythonPrintStmt> {
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<>;
26312 using fields_t = mp::List<describe_field_t<SgPythonPrintStmt,SgExpression*,&SgPythonPrintStmt::p_destination>, describe_field_t<SgPythonPrintStmt,SgExprListExp*,&SgPythonPrintStmt::p_values>>;
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;
26319 using field_type = SgScopeStatement*;
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};
26328template <> struct describe_node_t<SgQualifiedName> {
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<>;
26335 using fields_t = mp::List<describe_field_t<SgQualifiedName,SgScopeStatement*,&SgQualifiedName::p_scope>>;
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> {
26341 using parent = SgQualifiedNameType;
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> {
26352 using parent = SgQualifiedNameType;
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};
26362template <> struct describe_node_t<SgQualifiedNameType> {
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<>;
26369 using fields_t = mp::List<describe_field_t<SgQualifiedNameType,SgType*,&SgQualifiedNameType::p_base_type>, describe_field_t<SgQualifiedNameType,SgQualifiedNamePtrList,&SgQualifiedNameType::p_qualifiedNameList>>;
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<>;
26414 using fields_t = mp::List<describe_field_t<SgRangeExp,SgExpression*,&SgRangeExp::p_start>, describe_field_t<SgRangeExp,SgExpression*,&SgRangeExp::p_end>, describe_field_t<SgRangeExp,SgExpression*,&SgRangeExp::p_stride>>;
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> {
26420 using parent = SgRangeBasedForStatement;
26421 using field_type = SgVariableDeclaration*;
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> {
26431 using parent = SgRangeBasedForStatement;
26432 using field_type = SgVariableDeclaration*;
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> {
26442 using parent = SgRangeBasedForStatement;
26443 using field_type = SgVariableDeclaration*;
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> {
26453 using parent = SgRangeBasedForStatement;
26454 using field_type = SgVariableDeclaration*;
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> {
26464 using parent = SgRangeBasedForStatement;
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> {
26475 using parent = SgRangeBasedForStatement;
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> {
26486 using parent = SgRangeBasedForStatement;
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};
26684template <> struct describe_node_t<SgReadStatement> {
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<>;
26691 using fields_t = mp::List<describe_field_t<SgReadStatement,SgExpression*,&SgReadStatement::p_format>, describe_field_t<SgReadStatement,SgExpression*,&SgReadStatement::p_namelist>, describe_field_t<SgReadStatement,SgExpression*,&SgReadStatement::p_advance>, describe_field_t<SgReadStatement,SgExpression*,&SgReadStatement::p_asynchronous>, describe_field_t<SgReadStatement,SgExpression*,&SgReadStatement::p_blank>, describe_field_t<SgReadStatement,SgExpression*,&SgReadStatement::p_decimal>, describe_field_t<SgReadStatement,SgExpression*,&SgReadStatement::p_delim>, describe_field_t<SgReadStatement,SgExpression*,&SgReadStatement::p_end>, describe_field_t<SgReadStatement,SgExpression*,&SgReadStatement::p_eor>, describe_field_t<SgReadStatement,SgExpression*,&SgReadStatement::p_id>, describe_field_t<SgReadStatement,SgExpression*,&SgReadStatement::p_pad>, describe_field_t<SgReadStatement,SgExpression*,&SgReadStatement::p_pos>, describe_field_t<SgReadStatement,SgExpression*,&SgReadStatement::p_rec>, describe_field_t<SgReadStatement,SgExpression*,&SgReadStatement::p_round>, describe_field_t<SgReadStatement,SgExpression*,&SgReadStatement::p_sign>, describe_field_t<SgReadStatement,SgExpression*,&SgReadStatement::p_size>>;
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
26708template <> struct describe_field_t<SgRefExp,SgType*,&SgRefExp::p_type_name> {
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<>;
26726 using fields_t = mp::List<describe_field_t<SgRefExp,SgType*,&SgRefExp::p_type_name>>;
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};
26742template <> struct describe_node_t<SgReferenceType> {
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<>;
26749 using fields_t = mp::List<describe_field_t<SgReferenceType,SgType*,&SgReferenceType::p_base_type>>;
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<>;
26795 using fields_t = mp::List<describe_field_t<SgRenamePair,SgName,&SgRenamePair::p_local_name>, describe_field_t<SgRenamePair,SgName,&SgRenamePair::p_use_name>>;
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<>;
26829 using fields_t = mp::List<describe_field_t<SgRenameSymbol,SgSymbol*,&SgRenameSymbol::p_original_symbol>, describe_field_t<SgRenameSymbol,SgName,&SgRenameSymbol::p_new_name>>;
26830};
26831template <> struct node_from_variant_t<671> { using type = SgRenameSymbol; };
26832
26833// Class: ReplicationOp
26834template <> struct describe_node_t<SgReplicationOp> {
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<>;
26864 using fields_t = mp::List<describe_field_t<SgReturnStmt,SgExpression*,&SgReturnStmt::p_expression>>;
26865};
26866template <> struct node_from_variant_t<673> { using type = SgReturnStmt; };
26867
26868// Class: RewindStatement
26869template <> struct describe_node_t<SgRewindStatement> {
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
26881template <> struct describe_node_t<SgRshiftAssignOp> {
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> {
26906 using parent = SgRvalueReferenceType;
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};
26916template <> struct describe_node_t<SgRvalueReferenceType> {
26917 using node = SgRvalueReferenceType;
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<>;
26923 using fields_t = mp::List<describe_field_t<SgRvalueReferenceType,SgType*,&SgRvalueReferenceType::p_base_type>>;
26924};
26925template <> struct node_from_variant_t<677> { using type = SgRvalueReferenceType; };
26926
26927// Class: JavaUnsignedRshiftAssignOp
26928template <> struct describe_node_t<SgJavaUnsignedRshiftAssignOp> {
26929 using node = SgJavaUnsignedRshiftAssignOp;
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
26940template <> struct describe_node_t<SgJavaUnsignedRshiftOp> {
26941 using node = SgJavaUnsignedRshiftOp;
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
26964template <> struct describe_field_t<SgScopeStatement,SgSymbolTable*,&SgScopeStatement::p_symbol_table> {
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};
27030template <> struct describe_node_t<SgScopeStatement> {
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};
27036 using subclasses_t = mp::List<SgGlobal, SgBasicBlock, SgIfStmt, SgForStatement, SgFunctionDefinition, SgClassDefinition, SgWhileStmt, SgDoWhileStmt, SgSwitchStatement, SgCatchOptionStmt, SgNamespaceDefinitionStatement, SgBlockDataStatement, SgAssociateStatement, SgFortranDo, SgForAllStatement, SgUpcForAllStatement, SgCAFWithTeamStatement, SgJavaForEachStatement, SgJavaLabelStatement, SgMatlabForStatement, SgFunctionParameterScope, SgDeclarationScope, SgRangeBasedForStatement, SgJovialForThenStatement, SgAdaAcceptStmt, SgAdaPackageSpec, SgAdaPackageBody, SgAdaTaskSpec, SgAdaTaskBody, SgAdaProtectedBody, SgAdaProtectedSpec, SgAdaGenericDefn>;
27037 using fields_t = mp::List<describe_field_t<SgScopeStatement,SgSymbolTable*,&SgScopeStatement::p_symbol_table>, describe_field_t<SgScopeStatement,SgTypeTable*,&SgScopeStatement::p_type_table>, describe_field_t<SgScopeStatement,std::set<SgSymbol*>,&SgScopeStatement::p_type_elaboration_list>, describe_field_t<SgScopeStatement,std::set<SgSymbol*>,&SgScopeStatement::p_hidden_type_list>, describe_field_t<SgScopeStatement,std::set<SgSymbol*>,&SgScopeStatement::p_hidden_declaration_list>, describe_field_t<SgScopeStatement,SgPragma*,&SgScopeStatement::p_pragma>>;
27038};
27039template <> struct node_from_variant_t<681> { using type = SgScopeStatement; };
27040
27041// Class: SequenceStatement
27042template <> struct describe_node_t<SgSequenceStatement> {
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};
27076template <> struct describe_node_t<SgSetComprehension> {
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<>;
27083 using fields_t = mp::List<describe_field_t<SgSetComprehension,SgExpression*,&SgSetComprehension::p_element>, describe_field_t<SgSetComprehension,SgExprListExp*,&SgSetComprehension::p_generators>>;
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<>;
27117 using fields_t = mp::List<describe_field_t<SgShortVal,short,&SgShortVal::p_value>, describe_field_t<SgShortVal,std::string,&SgShortVal::p_valueString>>;
27118};
27119template <> struct node_from_variant_t<684> { using type = SgShortVal; };
27120
27121// Class: SizeOfOp
27122template <> struct describe_field_t<SgSizeOfOp,SgExpression*,&SgSizeOfOp::p_operand_expr> {
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};
27133template <> struct describe_field_t<SgSizeOfOp,SgType*,&SgSizeOfOp::p_operand_type> {
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};
27144template <> struct describe_field_t<SgSizeOfOp,SgType*,&SgSizeOfOp::p_expression_type> {
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};
27377template <> struct describe_node_t<SgJavaInstanceOfOp> {
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<>;
27384 using fields_t = mp::List<describe_field_t<SgJavaInstanceOfOp,SgExpression*,&SgJavaInstanceOfOp::p_operand_expr>, describe_field_t<SgJavaInstanceOfOp,SgType*,&SgJavaInstanceOfOp::p_operand_type>, describe_field_t<SgJavaInstanceOfOp,SgType*,&SgJavaInstanceOfOp::p_expression_type>>;
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;
27435 using field_type = SgJavaPackageStatement *;
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;
27446 using field_type = SgJavaImportStatementList*;
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;
27457 using field_type = SgJavaClassDeclarationList*;
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;
27490 using field_type = SgHeaderFileReport*;
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;
27613 using field_type = SgFunctionCallExp*;
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<>;
27629 using fields_t = mp::List<describe_field_t<SgSpawnStmt,SgFunctionCallExp*,&SgSpawnStmt::p_the_func>>;
27630};
27631template <> struct node_from_variant_t<690> { using type = SgSpawnStmt; };
27632
27633// Class: SyncAllStatement
27634template <> struct describe_node_t<SgSyncAllStatement> {
27635 using node = SgSyncAllStatement;
27636 using base = SgImageControlStatement;
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> {
27647 using parent = SgSyncImagesStatement;
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};
27657template <> struct describe_node_t<SgSyncImagesStatement> {
27658 using node = SgSyncImagesStatement;
27659 using base = SgImageControlStatement;
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<>;
27664 using fields_t = mp::List<describe_field_t<SgSyncImagesStatement,SgExpression*,&SgSyncImagesStatement::p_image_set>>;
27665};
27666template <> struct node_from_variant_t<692> { using type = SgSyncImagesStatement; };
27667
27668// Class: SyncMemoryStatement
27669template <> struct describe_node_t<SgSyncMemoryStatement> {
27670 using node = SgSyncMemoryStatement;
27671 using base = SgImageControlStatement;
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> {
27682 using parent = SgSyncTeamStatement;
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};
27692template <> struct describe_node_t<SgSyncTeamStatement> {
27693 using node = SgSyncTeamStatement;
27694 using base = SgImageControlStatement;
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<>;
27699 using fields_t = mp::List<describe_field_t<SgSyncTeamStatement,SgExpression*,&SgSyncTeamStatement::p_team_value>>;
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};
27715template <> struct describe_node_t<SgLockStatement> {
27716 using node = SgLockStatement;
27717 using base = SgImageControlStatement;
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<>;
27722 using fields_t = mp::List<describe_field_t<SgLockStatement,SgExpression*,&SgLockStatement::p_lock_variable>>;
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};
27738template <> struct describe_node_t<SgUnlockStatement> {
27739 using node = SgUnlockStatement;
27740 using base = SgImageControlStatement;
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<>;
27745 using fields_t = mp::List<describe_field_t<SgUnlockStatement,SgExpression*,&SgUnlockStatement::p_lock_variable>>;
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> {
27751 using parent = SgJavaThrowStatement;
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};
27761template <> struct describe_node_t<SgJavaThrowStatement> {
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<>;
27768 using fields_t = mp::List<describe_field_t<SgJavaThrowStatement,SgThrowOp*,&SgJavaThrowStatement::p_throwOp>>;
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> {
27774 using parent = SgJavaForEachStatement;
27775 using field_type = SgVariableDeclaration*;
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> {
27785 using parent = SgJavaForEachStatement;
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> {
27796 using parent = SgJavaForEachStatement;
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};
27806template <> struct describe_node_t<SgJavaForEachStatement> {
27807 using node = SgJavaForEachStatement;
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<>;
27813 using fields_t = mp::List<describe_field_t<SgJavaForEachStatement,SgVariableDeclaration*,&SgJavaForEachStatement::p_element>, describe_field_t<SgJavaForEachStatement,SgExpression*,&SgJavaForEachStatement::p_collection>, describe_field_t<SgJavaForEachStatement,SgStatement*,&SgJavaForEachStatement::p_loop_body>>;
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> {
27819 using parent = SgJavaSynchronizedStatement;
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> {
27830 using parent = SgJavaSynchronizedStatement;
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};
27840template <> struct describe_node_t<SgJavaSynchronizedStatement> {
27841 using node = SgJavaSynchronizedStatement;
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<>;
27847 using fields_t = mp::List<describe_field_t<SgJavaSynchronizedStatement,SgExpression*,&SgJavaSynchronizedStatement::p_expression>, describe_field_t<SgJavaSynchronizedStatement,SgStatement*,&SgJavaSynchronizedStatement::p_body>>;
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> {
27853 using parent = SgJavaParameterizedType;
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> {
27864 using parent = SgJavaParameterizedType;
27865 using field_type = SgTemplateParameterList*;
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};
27874template <> struct describe_node_t<SgJavaParameterizedType> {
27875 using node = SgJavaParameterizedType;
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<>;
27881 using fields_t = mp::List<describe_field_t<SgJavaParameterizedType,SgNamedType*,&SgJavaParameterizedType::p_raw_type>, describe_field_t<SgJavaParameterizedType,SgTemplateParameterList*,&SgJavaParameterizedType::p_type_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> {
27943 using parent = SgProcessControlStatement;
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> {
27954 using parent = SgProcessControlStatement;
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> {
27965 using parent = SgProcessControlStatement;
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> {
27988 using parent = SgSpecialFunctionModifier;
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};
27998template <> struct describe_node_t<SgSpecialFunctionModifier> {
27999 using node = SgSpecialFunctionModifier;
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<>;
28005 using fields_t = mp::List<describe_field_t<SgSpecialFunctionModifier,SgBitVector,&SgSpecialFunctionModifier::p_modifierVector>>;
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};
28038 using subclasses_t = mp::List<SgScopeStatement, SgFunctionTypeTable, SgDeclarationStatement, SgExprStatement, SgLabelStatement, SgCaseOptionStmt, SgTryStmt, SgDefaultOptionStmt, SgBreakStmt, SgContinueStmt, SgReturnStmt, SgGotoStatement, SgSpawnStmt, SgNullStatement, SgVariantStatement, SgForInitStatement, SgCatchStatementSeq, SgProcessControlStatement, SgIOStatement, SgFortranContinueStmt, SgWhereStatement, SgElseWhereStatement, SgNullifyStatement, SgArithmeticIfStatement, SgAssignStatement, SgComputedGotoStatement, SgAssignedGotoStatement, SgAllocateStatement, SgDeallocateStatement, SgUpcNotifyStatement, SgUpcWaitStatement, SgUpcBarrierStatement, SgUpcFenceStatement, SgOmpBarrierStatement, SgOmpTaskwaitStatement, SgOmpFlushStatement, SgOmpBodyStatement, SgSequenceStatement, SgWithStatement, SgPythonPrintStmt, SgPassStatement, SgAssertStmt, SgExecStatement, SgPythonGlobalStmt, SgJavaThrowStatement, SgJavaSynchronizedStatement, SgAsyncStmt, SgFinishStmt, SgAtStmt, SgAtomicStmt, SgWhenStmt, SgImageControlStatement, SgAdaExitStmt, SgAdaDelayStmt, SgAdaLoopStmt, SgAdaSelectStmt, SgAdaSelectAlternativeStmt, SgAdaTerminateStmt, SgAdaUnscopedBlock, SgAdaVariantWhenStmt>;
28039 using fields_t = mp::List<describe_field_t<SgStatement,SgLabelRefExp*,&SgStatement::p_numeric_label>, describe_field_t<SgStatement,int,&SgStatement::p_source_sequence_value>>;
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> {
28045 using parent = SgStaticAssertionDeclaration;
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> {
28056 using parent = SgStaticAssertionDeclaration;
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};
28066template <> struct describe_node_t<SgStaticAssertionDeclaration> {
28067 using node = SgStaticAssertionDeclaration;
28068 using base = SgDeclarationStatement;
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<>;
28073 using fields_t = mp::List<describe_field_t<SgStaticAssertionDeclaration,SgExpression*,&SgStaticAssertionDeclaration::p_condition>, describe_field_t<SgStaticAssertionDeclaration,SgName,&SgStaticAssertionDeclaration::p_string_literal>>;
28074};
28075template <> struct node_from_variant_t<705> { using type = SgStaticAssertionDeclaration; };
28076
28077// Class: StmtDeclarationStatement
28078template <> struct describe_field_t<SgStmtDeclarationStatement,SgStatement*,&SgStmtDeclarationStatement::p_statement> {
28079 using parent = SgStmtDeclarationStatement;
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};
28089template <> struct describe_node_t<SgStmtDeclarationStatement> {
28090 using node = SgStmtDeclarationStatement;
28091 using base = SgDeclarationStatement;
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<>;
28096 using fields_t = mp::List<describe_field_t<SgStmtDeclarationStatement,SgStatement*,&SgStmtDeclarationStatement::p_statement>>;
28097};
28098template <> struct node_from_variant_t<706> { using type = SgStmtDeclarationStatement; };
28099
28100// Class: StatementExpression
28101template <> struct describe_field_t<SgStatementExpression,SgStatement*,&SgStatementExpression::p_statement> {
28102 using parent = SgStatementExpression;
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};
28112template <> struct describe_node_t<SgStatementExpression> {
28113 using node = SgStatementExpression;
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<>;
28119 using fields_t = mp::List<describe_field_t<SgStatementExpression,SgStatement*,&SgStatementExpression::p_statement>>;
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> {
28125 using parent = SgStatementFunctionStatement;
28126 using field_type = SgFunctionDeclaration*;
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> {
28136 using parent = SgStatementFunctionStatement;
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};
28146template <> struct describe_node_t<SgStatementFunctionStatement> {
28147 using node = SgStatementFunctionStatement;
28148 using base = SgDeclarationStatement;
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<>;
28153 using fields_t = mp::List<describe_field_t<SgStatementFunctionStatement,SgFunctionDeclaration*,&SgStatementFunctionStatement::p_function>, describe_field_t<SgStatementFunctionStatement,SgExpression*,&SgStatementFunctionStatement::p_expression>>;
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;
28160 using field_type = SgStorageModifier::storage_modifier_enum;
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};
28180template <> struct describe_node_t<SgStorageModifier> {
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<>;
28187 using fields_t = mp::List<describe_field_t<SgStorageModifier,SgStorageModifier::storage_modifier_enum,&SgStorageModifier::p_modifier>, describe_field_t<SgStorageModifier,bool,&SgStorageModifier::p_thread_local_storage>>;
28188};
28189template <> struct node_from_variant_t<709> { using type = SgStorageModifier; };
28190
28191// Class: StringConversion
28192template <> struct describe_field_t<SgStringConversion,SgExpression*,&SgStringConversion::p_expression> {
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};
28203template <> struct describe_node_t<SgStringConversion> {
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<>;
28210 using fields_t = mp::List<describe_field_t<SgStringConversion,SgExpression*,&SgStringConversion::p_expression>>;
28211};
28212template <> struct node_from_variant_t<710> { using type = SgStringConversion; };
28213
28214// Class: StringKeyedBidirectionalGraph
28215template <> struct describe_node_t<SgStringKeyedBidirectionalGraph> {
28216 using node = SgStringKeyedBidirectionalGraph;
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> {
28317 using parent = SgStructureModifier;
28318 using field_type = SgStructureModifier::jovial_structure_modifier_enum;
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> {
28328 using parent = SgStructureModifier;
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};
28338template <> struct describe_node_t<SgStructureModifier> {
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<>;
28345 using fields_t = mp::List<describe_field_t<SgStructureModifier,SgStructureModifier::jovial_structure_modifier_enum,&SgStructureModifier::p_modifier>, describe_field_t<SgStructureModifier,int,&SgStructureModifier::p_bits_per_entry>>;
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> {
28351 using parent = SgSubscriptExpression;
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> {
28362 using parent = SgSubscriptExpression;
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> {
28373 using parent = SgSubscriptExpression;
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};
28383template <> struct describe_node_t<SgSubscriptExpression> {
28384 using node = SgSubscriptExpression;
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<>;
28390 using fields_t = mp::List<describe_field_t<SgSubscriptExpression,SgExpression*,&SgSubscriptExpression::p_lowerBound>, describe_field_t<SgSubscriptExpression,SgExpression*,&SgSubscriptExpression::p_upperBound>, describe_field_t<SgSubscriptExpression,SgExpression*,&SgSubscriptExpression::p_stride>>;
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};
28430template <> struct describe_field_t<SgSwitchStatement,SgStatement*,&SgSwitchStatement::p_body> {
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;
28477 using field_type = AstAttributeMechanism*;
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
28498template <> struct describe_field_t<SgSymbolTable,SgSymbolTable::hash_iterator,&SgSymbolTable::p_iterator> {
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};
28509template <> struct describe_field_t<SgSymbolTable,SgName,&SgSymbolTable::p_name> {
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};
28520template <> struct describe_field_t<SgSymbolTable,bool,&SgSymbolTable::p_no_name> {
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};
28531template <> struct describe_field_t<SgSymbolTable, rose_hash_multimap*,&SgSymbolTable::p_table> {
28532 using parent = SgSymbolTable;
28533 using field_type = rose_hash_multimap*;
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;
28578 using field_type = SgTemplateArgument::template_argument_enum;
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};
28587template <> struct describe_field_t<SgTemplateArgument,bool,&SgTemplateArgument::p_isArrayBoundUnknownType> {
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};
28598template <> struct describe_field_t<SgTemplateArgument,SgType*,&SgTemplateArgument::p_type> {
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};
28620template <> struct describe_field_t<SgTemplateArgument,SgExpression*,&SgTemplateArgument::p_expression> {
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;
28633 using field_type = SgDeclarationStatement*;
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;
28644 using field_type = SgInitializedName*;
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};
28653template <> struct describe_field_t<SgTemplateArgument,bool,&SgTemplateArgument::p_explicitlySpecified> {
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;
28743 using field_type = 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;
28754 using field_type = 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};
28774template <> struct describe_node_t<SgTemplateArgument> {
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> {
28787 using parent = SgTemplateArgumentList;
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};
28797template <> struct describe_node_t<SgTemplateArgumentList> {
28798 using node = SgTemplateArgumentList;
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<>;
28804 using fields_t = mp::List<describe_field_t<SgTemplateArgumentList,SgTemplateArgumentPtrList,&SgTemplateArgumentList::p_args>>;
28805};
28806template <> struct node_from_variant_t<721> { using type = SgTemplateArgumentList; };
28807
28808// Class: TemplateDeclaration
28809template <> struct describe_field_t<SgTemplateDeclaration,SgName,&SgTemplateDeclaration::p_name> {
28810 using parent = SgTemplateDeclaration;
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};
28820template <> struct describe_field_t<SgTemplateDeclaration,SgName,&SgTemplateDeclaration::p_string> {
28821 using parent = SgTemplateDeclaration;
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};
28831template <> struct describe_field_t<SgTemplateDeclaration,SgTemplateDeclaration::template_type_enum,&SgTemplateDeclaration::p_template_kind> {
28832 using parent = SgTemplateDeclaration;
28833 using field_type = SgTemplateDeclaration::template_type_enum;
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};
28842template <> struct describe_field_t<SgTemplateDeclaration,SgTemplateParameterPtrList,&SgTemplateDeclaration::p_templateParameters> {
28843 using parent = SgTemplateDeclaration;
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};
28853template <> struct describe_field_t<SgTemplateDeclaration,SgScopeStatement*,&SgTemplateDeclaration::p_scope> {
28854 using parent = SgTemplateDeclaration;
28855 using field_type = SgScopeStatement*;
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> {
28865 using parent = SgTemplateDeclaration;
28866 using field_type = SgDeclarationScope*;
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> {
28888 using parent = SgTemplateClassDeclaration;
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> {
28899 using parent = SgTemplateClassDeclaration;
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> {
28910 using parent = SgTemplateClassDeclaration;
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> {
28921 using parent = SgTemplateClassDeclaration;
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> {
28932 using parent = SgTemplateClassDeclaration;
28933 using field_type = SgDeclarationScope*;
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
28954template <> struct describe_node_t<SgTemplateClassSymbol> {
28955 using node = SgTemplateClassSymbol;
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> {
28967 using parent = SgTemplateFunctionDeclaration;
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> {
28978 using parent = SgTemplateFunctionDeclaration;
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> {
28989 using parent = SgTemplateFunctionDeclaration;
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> {
29000 using parent = SgTemplateFunctionDeclaration;
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> {
29011 using parent = SgTemplateFunctionDeclaration;
29012 using field_type = SgDeclarationScope*;
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> {
29034 using parent = SgTemplateFunctionRefExp;
29035 using field_type = SgTemplateFunctionSymbol*;
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> {
29045 using parent = SgTemplateFunctionRefExp;
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> {
29056 using parent = SgTemplateFunctionRefExp;
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> {
29067 using parent = SgTemplateFunctionRefExp;
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
29089template <> struct describe_node_t<SgTemplateFunctionSymbol> {
29090 using node = SgTemplateFunctionSymbol;
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> {
29102 using parent = SgTemplateMemberFunctionDeclaration;
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> {
29113 using parent = SgTemplateMemberFunctionDeclaration;
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> {
29124 using parent = SgTemplateMemberFunctionDeclaration;
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> {
29135 using parent = SgTemplateMemberFunctionDeclaration;
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> {
29146 using parent = SgTemplateMemberFunctionDeclaration;
29147 using field_type = SgDeclarationScope*;
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> {
29169 using parent = SgTemplateMemberFunctionRefExp;
29170 using field_type = SgTemplateMemberFunctionSymbol*;
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> {
29180 using parent = SgTemplateMemberFunctionRefExp;
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> {
29191 using parent = SgTemplateMemberFunctionRefExp;
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> {
29202 using parent = SgTemplateMemberFunctionRefExp;
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> {
29213 using parent = SgTemplateMemberFunctionRefExp;
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> {
29224 using parent = SgTemplateMemberFunctionRefExp;
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
29246template <> struct describe_node_t<SgTemplateMemberFunctionSymbol> {
29247 using node = SgTemplateMemberFunctionSymbol;
29248 using base = SgMemberFunctionSymbol;
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> {
29259 using parent = SgTemplateTypedefDeclaration;
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> {
29270 using parent = SgTemplateTypedefDeclaration;
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> {
29281 using parent = SgTemplateTypedefDeclaration;
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> {
29292 using parent = SgTemplateTypedefDeclaration;
29293 using field_type = SgDeclarationScope*;
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
29314template <> struct describe_node_t<SgTemplateTypedefSymbol> {
29315 using node = SgTemplateTypedefSymbol;
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> {
29327 using parent = SgTemplateVariableDeclaration;
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> {
29338 using parent = SgTemplateVariableDeclaration;
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> {
29349 using parent = SgTemplateVariableDeclaration;
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> {
29360 using parent = SgTemplateVariableDeclaration;
29361 using field_type = SgDeclarationScope*;
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
29382template <> struct describe_node_t<SgTemplateVariableSymbol> {
29383 using node = SgTemplateVariableSymbol;
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
29394template <> struct describe_node_t<SgTemplateClassDefinition> {
29395 using node = SgTemplateClassDefinition;
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
29406template <> struct describe_node_t<SgTemplateFunctionDefinition> {
29407 using node = SgTemplateFunctionDefinition;
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
29418template <> struct describe_field_t<SgTemplateInstantiationDecl,SgName,&SgTemplateInstantiationDecl::p_templateName> {
29419 using parent = SgTemplateInstantiationDecl;
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};
29429template <> struct describe_field_t<SgTemplateInstantiationDecl,SgName,&SgTemplateInstantiationDecl::p_templateHeader> {
29430 using parent = SgTemplateInstantiationDecl;
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};
29440template <> struct describe_field_t<SgTemplateInstantiationDecl,SgTemplateClassDeclaration*,&SgTemplateInstantiationDecl::p_templateDeclaration> {
29441 using parent = SgTemplateInstantiationDecl;
29442 using field_type = SgTemplateClassDeclaration*;
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};
29451template <> struct describe_field_t<SgTemplateInstantiationDecl,SgTemplateArgumentPtrList,&SgTemplateInstantiationDecl::p_templateArguments> {
29452 using parent = SgTemplateInstantiationDecl;
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};
29462template <> struct describe_field_t<SgTemplateInstantiationDecl,bool,&SgTemplateInstantiationDecl::p_nameResetFromMangledForm> {
29463 using parent = SgTemplateInstantiationDecl;
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
29485template <> struct describe_node_t<SgTemplateInstantiationDefn> {
29486 using node = SgTemplateInstantiationDefn;
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
29497template <> struct describe_field_t<SgTemplateInstantiationDirectiveStatement,SgDeclarationStatement*,&SgTemplateInstantiationDirectiveStatement::p_declaration> {
29498 using parent = SgTemplateInstantiationDirectiveStatement;
29499 using field_type = SgDeclarationStatement*;
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> {
29509 using parent = SgTemplateInstantiationDirectiveStatement;
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
29531template <> struct describe_field_t<SgTemplateInstantiationFunctionDecl,SgName,&SgTemplateInstantiationFunctionDecl::p_templateName> {
29532 using parent = SgTemplateInstantiationFunctionDecl;
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};
29542template <> struct describe_field_t<SgTemplateInstantiationFunctionDecl,SgTemplateFunctionDeclaration*,&SgTemplateInstantiationFunctionDecl::p_templateDeclaration> {
29543 using parent = SgTemplateInstantiationFunctionDecl;
29544 using field_type = SgTemplateFunctionDeclaration*;
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};
29553template <> struct describe_field_t<SgTemplateInstantiationFunctionDecl,SgTemplateArgumentPtrList,&SgTemplateInstantiationFunctionDecl::p_templateArguments> {
29554 using parent = SgTemplateInstantiationFunctionDecl;
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};
29564template <> struct describe_field_t<SgTemplateInstantiationFunctionDecl,bool,&SgTemplateInstantiationFunctionDecl::p_nameResetFromMangledForm> {
29565 using parent = SgTemplateInstantiationFunctionDecl;
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};
29571 static constexpr auto mbr_ptr{&SgTemplateInstantiationFunctionDecl::p_nameResetFromMangledForm};
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> {
29576 using parent = SgTemplateInstantiationFunctionDecl;
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
29598template <> struct describe_field_t<SgTemplateInstantiationMemberFunctionDecl,SgName,&SgTemplateInstantiationMemberFunctionDecl::p_templateName> {
29599 using parent = SgTemplateInstantiationMemberFunctionDecl;
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};
29609template <> struct describe_field_t<SgTemplateInstantiationMemberFunctionDecl,SgTemplateMemberFunctionDeclaration*,&SgTemplateInstantiationMemberFunctionDecl::p_templateDeclaration> {
29610 using parent = SgTemplateInstantiationMemberFunctionDecl;
29611 using field_type = SgTemplateMemberFunctionDeclaration*;
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};
29616 static constexpr auto mbr_ptr{&SgTemplateInstantiationMemberFunctionDecl::p_templateDeclaration};
29617 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29618 using bind = Desc<SgTemplateInstantiationMemberFunctionDecl, SgTemplateMemberFunctionDeclaration* SgTemplateInstantiationMemberFunctionDecl::*, &SgTemplateInstantiationMemberFunctionDecl::p_templateDeclaration>;
29619};
29620template <> struct describe_field_t<SgTemplateInstantiationMemberFunctionDecl,SgTemplateArgumentPtrList,&SgTemplateInstantiationMemberFunctionDecl::p_templateArguments> {
29621 using parent = SgTemplateInstantiationMemberFunctionDecl;
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};
29627 static constexpr auto mbr_ptr{&SgTemplateInstantiationMemberFunctionDecl::p_templateArguments};
29628 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
29629 using bind = Desc<SgTemplateInstantiationMemberFunctionDecl, SgTemplateArgumentPtrList SgTemplateInstantiationMemberFunctionDecl::*, &SgTemplateInstantiationMemberFunctionDecl::p_templateArguments>;
29630};
29631template <> struct describe_field_t<SgTemplateInstantiationMemberFunctionDecl,bool,&SgTemplateInstantiationMemberFunctionDecl::p_nameResetFromMangledForm> {
29632 using parent = SgTemplateInstantiationMemberFunctionDecl;
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};
29638 static constexpr auto mbr_ptr{&SgTemplateInstantiationMemberFunctionDecl::p_nameResetFromMangledForm};
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> {
29643 using parent = SgTemplateInstantiationMemberFunctionDecl;
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> {
29666 using parent = SgTemplateInstantiationTypedefDeclaration;
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> {
29677 using parent = SgTemplateInstantiationTypedefDeclaration;
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> {
29688 using parent = SgTemplateInstantiationTypedefDeclaration;
29689 using field_type = SgTemplateTypedefDeclaration*;
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> {
29699 using parent = SgTemplateInstantiationTypedefDeclaration;
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> {
29710 using parent = SgTemplateInstantiationTypedefDeclaration;
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> {
29733 using parent = SgTemplateParameter;
29734 using field_type = SgTemplateParameter::template_parameter_enum;
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> {
29744 using parent = SgTemplateParameter;
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> {
29755 using parent = SgTemplateParameter;
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> {
29766 using parent = SgTemplateParameter;
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> {
29777 using parent = SgTemplateParameter;
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> {
29788 using parent = SgTemplateParameter;
29789 using field_type = SgDeclarationStatement*;
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> {
29799 using parent = SgTemplateParameter;
29800 using field_type = SgDeclarationStatement*;
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> {
29810 using parent = SgTemplateParameter;
29811 using field_type = SgInitializedName*;
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> {
29833 using parent = SgTemplateParameterVal;
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> {
29844 using parent = SgTemplateParameterVal;
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> {
29855 using parent = SgTemplateParameterVal;
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};
29865template <> struct describe_node_t<SgTemplateParameterVal> {
29866 using node = SgTemplateParameterVal;
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<>;
29872 using fields_t = mp::List<describe_field_t<SgTemplateParameterVal,int,&SgTemplateParameterVal::p_template_parameter_position>, describe_field_t<SgTemplateParameterVal,std::string,&SgTemplateParameterVal::p_valueString>, describe_field_t<SgTemplateParameterVal,SgType*,&SgTemplateParameterVal::p_valueType>>;
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> {
29878 using parent = SgTemplateParameterList;
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};
29888template <> struct describe_node_t<SgTemplateParameterList> {
29889 using node = SgTemplateParameterList;
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<>;
29895 using fields_t = mp::List<describe_field_t<SgTemplateParameterList,SgTemplateParameterPtrList,&SgTemplateParameterList::p_args>>;
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;
29902 using field_type = SgTemplateDeclaration*;
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};
29911template <> struct describe_node_t<SgTemplateSymbol> {
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<>;
29918 using fields_t = mp::List<describe_field_t<SgTemplateSymbol,SgTemplateDeclaration*,&SgTemplateSymbol::p_declaration>>;
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;
29980 using field_type = SgTemplateParameter *;
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
30034template <> struct describe_field_t<SgThisExp,SgClassSymbol*,&SgThisExp::p_class_symbol> {
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};
30056template <> struct describe_field_t<SgThisExp,int,&SgThisExp::p_pobj_this> {
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<>;
30074 using fields_t = mp::List<describe_field_t<SgThisExp,SgClassSymbol*,&SgThisExp::p_class_symbol>, describe_field_t<SgThisExp,SgNonrealSymbol*,&SgThisExp::p_nonreal_symbol>, describe_field_t<SgThisExp,int,&SgThisExp::p_pobj_this>>;
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> {
30080 using parent = SgTypeTraitBuiltinOperator;
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> {
30091 using parent = SgTypeTraitBuiltinOperator;
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};
30101template <> struct describe_node_t<SgTypeTraitBuiltinOperator> {
30102 using node = SgTypeTraitBuiltinOperator;
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<>;
30108 using fields_t = mp::List<describe_field_t<SgTypeTraitBuiltinOperator,SgName,&SgTypeTraitBuiltinOperator::p_name>, describe_field_t<SgTypeTraitBuiltinOperator,SgNodePtrList,&SgTypeTraitBuiltinOperator::p_args>>;
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<>;
30142 using fields_t = mp::List<describe_field_t<SgSuperExp,SgClassSymbol*,&SgSuperExp::p_class_symbol>, describe_field_t<SgSuperExp,int,&SgSuperExp::p_pobj_super>>;
30143};
30144template <> struct node_from_variant_t<750> { using type = SgSuperExp; };
30145
30146// Class: ThrowOp
30147template <> struct describe_field_t<SgThrowOp,SgThrowOp::e_throw_kind,&SgThrowOp::p_throwKind> {
30148 using parent = SgThrowOp;
30149 using field_type = SgThrowOp::e_throw_kind;
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<>;
30165 using fields_t = mp::List<describe_field_t<SgThrowOp,SgThrowOp::e_throw_kind,&SgThrowOp::p_throwKind>>;
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<>;
30199 using fields_t = mp::List<describe_field_t<SgToken,std::string,&SgToken::p_lexeme_string>, describe_field_t<SgToken,unsigned int,&SgToken::p_classification_code>>;
30200};
30201template <> struct node_from_variant_t<752> { using type = SgToken; };
30202
30203// Class: TryStmt
30204template <> struct describe_field_t<SgTryStmt,SgStatement*,&SgTryStmt::p_body> {
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};
30215template <> struct describe_field_t<SgTryStmt,SgCatchStatementSeq*,&SgTryStmt::p_catch_statement_seq_root> {
30216 using parent = SgTryStmt;
30217 using field_type = SgCatchStatementSeq*;
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};
30226template <> struct describe_field_t<SgTryStmt,SgStatement*,&SgTryStmt::p_else_body> {
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};
30237template <> struct describe_field_t<SgTryStmt,SgStatement*,&SgTryStmt::p_finally_body> {
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<>;
30255 using fields_t = mp::List<describe_field_t<SgTryStmt,SgStatement*,&SgTryStmt::p_body>, describe_field_t<SgTryStmt,SgCatchStatementSeq*,&SgTryStmt::p_catch_statement_seq_root>, describe_field_t<SgTryStmt,SgStatement*,&SgTryStmt::p_else_body>, describe_field_t<SgTryStmt,SgStatement*,&SgTryStmt::p_finally_body>>;
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};
30283template <> struct describe_field_t<SgType,int,&SgType::p_substitutedForTemplateParam> {
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};
30294template <> struct describe_field_t<SgType,SgReferenceType*,&SgType::p_ref_to> {
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};
30305template <> struct describe_field_t<SgType,SgPointerType*,&SgType::p_ptr_to> {
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};
30316template <> struct describe_field_t<SgType,SgModifierNodes*,&SgType::p_modifiers> {
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};
30327template <> struct describe_field_t<SgType,SgTypedefSeq*,&SgType::p_typedefs> {
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;
30340 using field_type = SgRvalueReferenceType*;
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;
30395 using field_type = AstAttributeMechanism*;
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};
30410 using subclasses_t = mp::List<SgTypeUnknown, SgTypeChar, SgTypeSignedChar, SgTypeUnsignedChar, SgTypeShort, SgTypeSignedShort, SgTypeUnsignedShort, SgTypeInt, SgTypeSignedInt, SgTypeUnsignedInt, SgTypeLong, SgTypeSignedLong, SgTypeUnsignedLong, SgTypeVoid, SgTypeGlobalVoid, SgTypeWchar, SgTypeFloat, SgTypeDouble, SgTypeLongLong, SgTypeSignedLongLong, SgTypeUnsignedLongLong, SgTypeSigned128bitInteger, SgTypeUnsigned128bitInteger, SgTypeFloat80, SgTypeLongDouble, SgTypeString, SgTypeBool, SgPointerType, SgReferenceType, SgNamedType, SgModifierType, SgFunctionType, SgArrayType, SgTypeEllipse, SgTemplateType, SgQualifiedNameType, SgTypeComplex, SgTypeImaginary, SgTypeDefault, SgTypeCAFTeam, SgTypeCrayPointer, SgTypeLabel, SgJavaUnionType, SgRvalueReferenceType, SgTypeNullptr, SgDeclType, SgTypeOfType, SgTypeMatrix, SgTypeTuple, SgTypeChar16, SgTypeChar32, SgTypeFloat128, SgTypeFixed, SgAutoType, SgAdaAccessType, SgAdaSubtype, SgAdaDiscreteType, SgAdaModularType, SgAdaDerivedType, SgAdaSubroutineType, SgJovialBitType, SgRangeType>;
30411 using fields_t = mp::List<describe_field_t<SgType,bool,&SgType::p_isCoArray>, describe_field_t<SgType,int,&SgType::p_substitutedForTemplateParam>, describe_field_t<SgType,SgReferenceType*,&SgType::p_ref_to>, describe_field_t<SgType,SgPointerType*,&SgType::p_ptr_to>, describe_field_t<SgType,SgModifierNodes*,&SgType::p_modifiers>, describe_field_t<SgType,SgTypedefSeq*,&SgType::p_typedefs>, describe_field_t<SgType,SgRvalueReferenceType*,&SgType::p_rvalue_ref_to>, describe_field_t<SgType,SgDeclType*,&SgType::p_decltype_ref_to>, describe_field_t<SgType,SgTypeOfType*,&SgType::p_typeof_ref_to>, describe_field_t<SgType,SgExpression*,&SgType::p_type_kind>, describe_field_t<SgType,bool,&SgType::p_hasTypeKindStar>, describe_field_t<SgType,AstAttributeMechanism*,&SgType::p_attributeMechanism>>;
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<>;
30482 using fields_t = mp::List<describe_field_t<SgTypeComplex,SgType*,&SgTypeComplex::p_base_type>>;
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<>;
30505 using fields_t = mp::List<describe_field_t<SgTypeDefault,SgName,&SgTypeDefault::p_name>>;
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};
30521template <> struct describe_node_t<SgTypeExpression> {
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<>;
30528 using fields_t = mp::List<describe_field_t<SgTypeExpression,SgType*,&SgTypeExpression::p_type>>;
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<>;
30551 using fields_t = mp::List<describe_field_t<SgTypeLabel,SgName,&SgTypeLabel::p_name>>;
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<>;
30609 using fields_t = mp::List<describe_field_t<SgTypeFixed,SgExpression*,&SgTypeFixed::p_scale>, describe_field_t<SgTypeFixed,SgExpression*,&SgTypeFixed::p_fraction>>;
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
30650template <> struct describe_node_t<SgTypeGlobalVoid> {
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};
30773template <> struct describe_node_t<SgTypeImaginary> {
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<>;
30780 using fields_t = mp::List<describe_field_t<SgTypeImaginary,SgType*,&SgTypeImaginary::p_base_type>>;
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<>;
30803 using fields_t = mp::List<describe_field_t<SgTypeInt,int,&SgTypeInt::p_field_size>>;
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
30820template <> struct describe_node_t<SgTypeLongDouble> {
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;
30857 using field_type = SgUPC_AccessModifier;
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;
30868 using field_type = SgStructureModifier;
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;
30879 using field_type = SgConstVolatileModifier;
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;
30890 using field_type = SgElaboratedTypeModifier;
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;
30901 using field_type = SgTypeModifier::gnu_extension_machine_mode_enum;
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<>;
30984 using fields_t = mp::List<describe_field_t<SgTypeMatrix,SgType*,&SgTypeMatrix::p_base_type>>;
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<>;
31007 using fields_t = mp::List<describe_field_t<SgTypeTuple,SgTypePtrList,&SgTypeTuple::p_types>>;
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<>;
31053 using fields_t = mp::List<describe_field_t<SgTypeOfType,SgExpression*,&SgTypeOfType::p_base_expression>, describe_field_t<SgTypeOfType,SgType*,&SgTypeOfType::p_base_type>>;
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
31070template <> struct describe_node_t<SgTypeSigned128bitInteger> {
31071 using node = SgTypeSigned128bitInteger;
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
31082template <> struct describe_node_t<SgTypeSignedChar> {
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
31094template <> struct describe_node_t<SgTypeSignedInt> {
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
31106template <> struct describe_node_t<SgTypeSignedLong> {
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
31118template <> struct describe_node_t<SgTypeSignedLongLong> {
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
31130template <> struct describe_node_t<SgTypeSignedShort> {
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<>;
31160 using fields_t = mp::List<describe_field_t<SgTypeString,SgExpression*,&SgTypeString::p_lengthExpression>>;
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<>;
31194 using fields_t = mp::List<describe_field_t<SgTypeUnknown,std::string,&SgTypeUnknown::p_type_name>, describe_field_t<SgTypeUnknown,bool,&SgTypeUnknown::p_has_type_name>>;
31195};
31196template <> struct node_from_variant_t<790> { using type = SgTypeUnknown; };
31197
31198// Class: TypeUnsigned128bitInteger
31199template <> struct describe_node_t<SgTypeUnsigned128bitInteger> {
31200 using node = SgTypeUnsigned128bitInteger;
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
31211template <> struct describe_node_t<SgTypeUnsignedChar> {
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
31223template <> struct describe_node_t<SgTypeUnsignedInt> {
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
31235template <> struct describe_node_t<SgTypeUnsignedLong> {
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
31247template <> struct describe_node_t<SgTypeUnsignedLongLong> {
31248 using node = SgTypeUnsignedLongLong;
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
31259template <> struct describe_node_t<SgTypeUnsignedShort> {
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
31295template <> struct describe_field_t<SgTypedefDeclaration,SgName,&SgTypedefDeclaration::p_name> {
31296 using parent = SgTypedefDeclaration;
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};
31306template <> struct describe_field_t<SgTypedefDeclaration,SgType*,&SgTypedefDeclaration::p_base_type> {
31307 using parent = SgTypedefDeclaration;
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};
31317template <> struct describe_field_t<SgTypedefDeclaration,SgTypedefType*,&SgTypedefDeclaration::p_type> {
31318 using parent = SgTypedefDeclaration;
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};
31328template <> struct describe_field_t<SgTypedefDeclaration,SgDeclarationStatement*,&SgTypedefDeclaration::p_declaration> {
31329 using parent = SgTypedefDeclaration;
31330 using field_type = SgDeclarationStatement*;
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};
31339template <> struct describe_field_t<SgTypedefDeclaration,SgSymbol*,&SgTypedefDeclaration::p_parent_scope> {
31340 using parent = SgTypedefDeclaration;
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};
31350template <> struct describe_field_t<SgTypedefDeclaration,bool,&SgTypedefDeclaration::p_typedefBaseTypeContainsDefiningDeclaration> {
31351 using parent = SgTypedefDeclaration;
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};
31357 static constexpr auto mbr_ptr{&SgTypedefDeclaration::p_typedefBaseTypeContainsDefiningDeclaration};
31358 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
31359 using bind = Desc<SgTypedefDeclaration, bool SgTypedefDeclaration::*, &SgTypedefDeclaration::p_typedefBaseTypeContainsDefiningDeclaration>;
31360};
31361template <> struct describe_field_t<SgTypedefDeclaration,SgScopeStatement*,&SgTypedefDeclaration::p_scope> {
31362 using parent = SgTypedefDeclaration;
31363 using field_type = SgScopeStatement*;
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> {
31373 using parent = SgTypedefDeclaration;
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> {
31384 using parent = SgTypedefDeclaration;
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> {
31395 using parent = SgTypedefDeclaration;
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> {
31406 using parent = SgTypedefDeclaration;
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> {
31417 using parent = SgTypedefDeclaration;
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> {
31428 using parent = SgTypedefDeclaration;
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> {
31439 using parent = SgTypedefDeclaration;
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> {
31450 using parent = SgTypedefDeclaration;
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> {
31461 using parent = SgTypedefDeclaration;
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> {
31472 using parent = SgTypedefDeclaration;
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};
31482template <> struct describe_node_t<SgTypedefDeclaration> {
31483 using node = SgTypedefDeclaration;
31484 using base = SgDeclarationStatement;
31485 static constexpr char const * const name{"TypedefDeclaration"};
31486 static constexpr unsigned long variant{799};
31487 static constexpr bool concrete{true};
31488 using subclasses_t = mp::List<SgTemplateTypedefDeclaration, SgTemplateInstantiationTypedefDeclaration>;
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<>;
31512 using fields_t = mp::List<describe_field_t<SgTypedefSeq,SgTypePtrList,&SgTypedefSeq::p_typedefs>>;
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;
31519 using field_type = SgTypedefDeclaration*;
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};
31528template <> struct describe_node_t<SgTypedefSymbol> {
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};
31534 using subclasses_t = mp::List<SgTemplateTypedefSymbol>;
31535 using fields_t = mp::List<describe_field_t<SgTypedefSymbol,SgTypedefDeclaration*,&SgTypedefSymbol::p_declaration>>;
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<>;
31558 using fields_t = mp::List<describe_field_t<SgTypedefType,SgSymbol*,&SgTypedefType::p_parent_scope>>;
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> {
31564 using parent = SgUPC_AccessModifier;
31565 using field_type = SgUPC_AccessModifier::upc_access_modifier_enum;
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> {
31575 using parent = SgUPC_AccessModifier;
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> {
31586 using parent = SgUPC_AccessModifier;
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};
31596template <> struct describe_node_t<SgUPC_AccessModifier> {
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<>;
31603 using fields_t = mp::List<describe_field_t<SgUPC_AccessModifier,SgUPC_AccessModifier::upc_access_modifier_enum,&SgUPC_AccessModifier::p_modifier>, describe_field_t<SgUPC_AccessModifier,bool,&SgUPC_AccessModifier::p_isShared>, describe_field_t<SgUPC_AccessModifier,long,&SgUPC_AccessModifier::p_layout>>;
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
31620template <> struct describe_field_t<SgUnaryOp,SgExpression*,&SgUnaryOp::p_operand_i> {
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};
31631template <> struct describe_field_t<SgUnaryOp,SgType*,&SgUnaryOp::p_expression_type> {
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};
31642template <> struct describe_field_t<SgUnaryOp,SgUnaryOp::Sgop_mode,&SgUnaryOp::p_mode> {
31643 using parent = SgUnaryOp;
31644 using field_type = SgUnaryOp::Sgop_mode;
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
31665template <> struct describe_node_t<SgUndefDirectiveStatement> {
31666 using node = SgUndefDirectiveStatement;
31667 using base = SgC_PreprocessorDirectiveStatement;
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
31677template <> struct describe_node_t<SgUndirectedGraphEdge> {
31678 using node = SgUndirectedGraphEdge;
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> {
31690 using parent = SgUnknownArrayOrFunctionReference;
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> {
31701 using parent = SgUnknownArrayOrFunctionReference;
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> {
31712 using parent = SgUnknownArrayOrFunctionReference;
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<>;
31752 using fields_t = mp::List<describe_field_t<SgUnknownFile,SgGlobal*,&SgUnknownFile::p_globalScope>>;
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;
31814 using field_type = SgDeclarationStatement*;
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;
31825 using field_type = SgDeclarationStatement*;
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;
31858 using field_type = SgNamespaceDeclarationStatement*;
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;
31891 using field_type = SgFunctionCallExp*;
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;
31902 using field_type = SgScopeStatement*;
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;
31968 using field_type = SgFile::languageOption_enum;
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;
32012 using field_type = SgDeclarationStatement*;
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};
32066template <> struct describe_node_t<SgUnsignedCharVal> {
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<>;
32073 using fields_t = mp::List<describe_field_t<SgUnsignedCharVal,unsigned char,&SgUnsignedCharVal::p_value>, describe_field_t<SgUnsignedCharVal,std::string,&SgUnsignedCharVal::p_valueString>>;
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};
32100template <> struct describe_node_t<SgUnsignedIntVal> {
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<>;
32107 using fields_t = mp::List<describe_field_t<SgUnsignedIntVal,unsigned int,&SgUnsignedIntVal::p_value>, describe_field_t<SgUnsignedIntVal,std::string,&SgUnsignedIntVal::p_valueString>>;
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> {
32113 using parent = SgUnsignedLongLongIntVal;
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> {
32124 using parent = SgUnsignedLongLongIntVal;
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};
32134template <> struct describe_node_t<SgUnsignedLongLongIntVal> {
32135 using node = SgUnsignedLongLongIntVal;
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<>;
32141 using fields_t = mp::List<describe_field_t<SgUnsignedLongLongIntVal,unsigned long long int,&SgUnsignedLongLongIntVal::p_value>, describe_field_t<SgUnsignedLongLongIntVal,std::string,&SgUnsignedLongLongIntVal::p_valueString>>;
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};
32168template <> struct describe_node_t<SgUnsignedLongVal> {
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<>;
32175 using fields_t = mp::List<describe_field_t<SgUnsignedLongVal,unsigned long,&SgUnsignedLongVal::p_value>, describe_field_t<SgUnsignedLongVal,std::string,&SgUnsignedLongVal::p_valueString>>;
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};
32202template <> struct describe_node_t<SgUnsignedShortVal> {
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<>;
32209 using fields_t = mp::List<describe_field_t<SgUnsignedShortVal,unsigned short,&SgUnsignedShortVal::p_value>, describe_field_t<SgUnsignedShortVal,std::string,&SgUnsignedShortVal::p_valueString>>;
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> {
32215 using parent = SgUpcBarrierStatement;
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};
32225template <> struct describe_node_t<SgUpcBarrierStatement> {
32226 using node = SgUpcBarrierStatement;
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<>;
32232 using fields_t = mp::List<describe_field_t<SgUpcBarrierStatement,SgExpression*,&SgUpcBarrierStatement::p_barrier_expression>>;
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> {
32238 using parent = SgUpcBlocksizeofExpression;
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> {
32249 using parent = SgUpcBlocksizeofExpression;
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> {
32260 using parent = SgUpcBlocksizeofExpression;
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> {
32283 using parent = SgUpcElemsizeofExpression;
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> {
32294 using parent = SgUpcElemsizeofExpression;
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> {
32305 using parent = SgUpcElemsizeofExpression;
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
32327template <> struct describe_node_t<SgUpcFenceStatement> {
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> {
32340 using parent = SgUpcForAllStatement;
32341 using field_type = SgForInitStatement*;
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> {
32351 using parent = SgUpcForAllStatement;
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> {
32362 using parent = SgUpcForAllStatement;
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> {
32373 using parent = SgUpcForAllStatement;
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> {
32384 using parent = SgUpcForAllStatement;
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> {
32407 using parent = SgUpcLocalsizeofExpression;
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> {
32418 using parent = SgUpcLocalsizeofExpression;
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> {
32429 using parent = SgUpcLocalsizeofExpression;
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<>;
32480 using fields_t = mp::List<describe_field_t<SgUpcMythread,int,&SgUpcMythread::p_value>, describe_field_t<SgUpcMythread,std::string,&SgUpcMythread::p_valueString>>;
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> {
32486 using parent = SgUpcNotifyStatement;
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};
32496template <> struct describe_node_t<SgUpcNotifyStatement> {
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<>;
32503 using fields_t = mp::List<describe_field_t<SgUpcNotifyStatement,SgExpression*,&SgUpcNotifyStatement::p_notify_expression>>;
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<>;
32537 using fields_t = mp::List<describe_field_t<SgUpcThreads,int,&SgUpcThreads::p_value>, describe_field_t<SgUpcThreads,std::string,&SgUpcThreads::p_valueString>>;
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};
32553template <> struct describe_node_t<SgUpcWaitStatement> {
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<>;
32560 using fields_t = mp::List<describe_field_t<SgUpcWaitStatement,SgExpression*,&SgUpcWaitStatement::p_wait_expression>>;
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;
32611 using field_type = SgModuleStatement*;
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> {
32633 using parent = SgUserDefinedBinaryOp;
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> {
32644 using parent = SgUserDefinedBinaryOp;
32645 using field_type = SgFunctionSymbol*;
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};
32654template <> struct describe_node_t<SgUserDefinedBinaryOp> {
32655 using node = SgUserDefinedBinaryOp;
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<>;
32661 using fields_t = mp::List<describe_field_t<SgUserDefinedBinaryOp,SgName,&SgUserDefinedBinaryOp::p_operator_name>, describe_field_t<SgUserDefinedBinaryOp,SgFunctionSymbol*,&SgUserDefinedBinaryOp::p_symbol>>;
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> {
32667 using parent = SgUserDefinedUnaryOp;
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> {
32678 using parent = SgUserDefinedUnaryOp;
32679 using field_type = SgFunctionSymbol*;
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};
32688template <> struct describe_node_t<SgUserDefinedUnaryOp> {
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<>;
32695 using fields_t = mp::List<describe_field_t<SgUserDefinedUnaryOp,SgName,&SgUserDefinedUnaryOp::p_operator_name>, describe_field_t<SgUserDefinedUnaryOp,SgFunctionSymbol*,&SgUserDefinedUnaryOp::p_symbol>>;
32696};
32697template <> struct node_from_variant_t<829> { using type = SgUserDefinedUnaryOp; };
32698
32699// Class: UsingDeclarationStatement
32700template <> struct describe_field_t<SgUsingDeclarationStatement,SgDeclarationStatement*,&SgUsingDeclarationStatement::p_declaration> {
32701 using parent = SgUsingDeclarationStatement;
32702 using field_type = SgDeclarationStatement*;
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};
32711template <> struct describe_field_t<SgUsingDeclarationStatement,SgInitializedName*,&SgUsingDeclarationStatement::p_initializedName> {
32712 using parent = SgUsingDeclarationStatement;
32713 using field_type = SgInitializedName*;
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> {
32723 using parent = SgUsingDeclarationStatement;
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> {
32734 using parent = SgUsingDeclarationStatement;
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> {
32745 using parent = SgUsingDeclarationStatement;
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> {
32756 using parent = SgUsingDeclarationStatement;
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> {
32767 using parent = SgUsingDeclarationStatement;
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
32789template <> struct describe_field_t<SgUsingDirectiveStatement,SgNamespaceDeclarationStatement*,&SgUsingDirectiveStatement::p_namespaceDeclaration> {
32790 using parent = SgUsingDirectiveStatement;
32791 using field_type = SgNamespaceDeclarationStatement*;
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> {
32801 using parent = SgUsingDirectiveStatement;
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> {
32812 using parent = SgUsingDirectiveStatement;
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> {
32823 using parent = SgUsingDirectiveStatement;
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<>;
32908 using fields_t = mp::List<describe_field_t<SgVarArgCopyOp,SgExpression*,&SgVarArgCopyOp::p_lhs_operand>, describe_field_t<SgVarArgCopyOp,SgExpression*,&SgVarArgCopyOp::p_rhs_operand>, describe_field_t<SgVarArgCopyOp,SgType*,&SgVarArgCopyOp::p_expression_type>>;
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<>;
32942 using fields_t = mp::List<describe_field_t<SgVarArgEndOp,SgExpression*,&SgVarArgEndOp::p_operand_expr>, describe_field_t<SgVarArgEndOp,SgType*,&SgVarArgEndOp::p_expression_type>>;
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<>;
32976 using fields_t = mp::List<describe_field_t<SgVarArgOp,SgExpression*,&SgVarArgOp::p_operand_expr>, describe_field_t<SgVarArgOp,SgType*,&SgVarArgOp::p_expression_type>>;
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> {
32982 using parent = SgVarArgStartOneOperandOp;
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> {
32993 using parent = SgVarArgStartOneOperandOp;
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};
33003template <> struct describe_node_t<SgVarArgStartOneOperandOp> {
33004 using node = SgVarArgStartOneOperandOp;
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<>;
33010 using fields_t = mp::List<describe_field_t<SgVarArgStartOneOperandOp,SgExpression*,&SgVarArgStartOneOperandOp::p_operand_expr>, describe_field_t<SgVarArgStartOneOperandOp,SgType*,&SgVarArgStartOneOperandOp::p_expression_type>>;
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};
33048template <> struct describe_node_t<SgVarArgStartOp> {
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<>;
33055 using fields_t = mp::List<describe_field_t<SgVarArgStartOp,SgExpression*,&SgVarArgStartOp::p_lhs_operand>, describe_field_t<SgVarArgStartOp,SgExpression*,&SgVarArgStartOp::p_rhs_operand>, describe_field_t<SgVarArgStartOp,SgType*,&SgVarArgStartOp::p_expression_type>>;
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;
33062 using field_type = SgVariableSymbol*;
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
33127template <> struct describe_field_t<SgVariableDeclaration,SgDeclarationStatement*,&SgVariableDeclaration::p_baseTypeDefiningDeclaration> {
33128 using parent = SgVariableDeclaration;
33129 using field_type = SgDeclarationStatement*;
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};
33138template <> struct describe_field_t<SgVariableDeclaration,SgInitializedNamePtrList,&SgVariableDeclaration::p_variables> {
33139 using parent = SgVariableDeclaration;
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};
33149template <> struct describe_field_t<SgVariableDeclaration,bool,&SgVariableDeclaration::p_variableDeclarationContainsBaseTypeDefiningDeclaration> {
33150 using parent = SgVariableDeclaration;
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};
33156 static constexpr auto mbr_ptr{&SgVariableDeclaration::p_variableDeclarationContainsBaseTypeDefiningDeclaration};
33157 template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
33158 using bind = Desc<SgVariableDeclaration, bool SgVariableDeclaration::*, &SgVariableDeclaration::p_variableDeclarationContainsBaseTypeDefiningDeclaration>;
33159};
33160template <> struct describe_field_t<SgVariableDeclaration,SgDeclarationStatement::template_specialization_enum,&SgVariableDeclaration::p_specialization> {
33161 using parent = SgVariableDeclaration;
33162 using field_type = SgDeclarationStatement::template_specialization_enum;
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> {
33172 using parent = SgVariableDeclaration;
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> {
33183 using parent = SgVariableDeclaration;
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> {
33194 using parent = SgVariableDeclaration;
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> {
33205 using parent = SgVariableDeclaration;
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> {
33216 using parent = SgVariableDeclaration;
33217 using field_type = SgDeclarationStatement::gnu_extension_visability_attribute_enum;
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> {
33227 using parent = SgVariableDeclaration;
33228 using field_type = SgVariableDeclaration::gnu_extension_declaration_attributes_enum;
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> {
33238 using parent = SgVariableDeclaration;
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> {
33249 using parent = SgVariableDeclaration;
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> {
33260 using parent = SgVariableDeclaration;
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> {
33271 using parent = SgVariableDeclaration;
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> {
33282 using parent = SgVariableDeclaration;
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> {
33293 using parent = SgVariableDeclaration;
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> {
33304 using parent = SgVariableDeclaration;
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> {
33315 using parent = SgVariableDeclaration;
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};
33325template <> struct describe_node_t<SgVariableDeclaration> {
33326 using node = SgVariableDeclaration;
33327 using base = SgDeclarationStatement;
33328 static constexpr char const * const name{"VariableDeclaration"};
33329 static constexpr unsigned long variant{839};
33330 static constexpr bool concrete{true};
33331 using subclasses_t = mp::List<SgTemplateVariableDeclaration, SgTemplateVariableInstantiation>;
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
33337template <> struct describe_field_t<SgVariableDefinition,SgInitializedName*,&SgVariableDefinition::p_vardefn> {
33338 using parent = SgVariableDefinition;
33339 using field_type = SgInitializedName*;
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};
33348template <> struct describe_field_t<SgVariableDefinition,SgExpression*,&SgVariableDefinition::p_bitfield> {
33349 using parent = SgVariableDefinition;
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};
33359template <> struct describe_node_t<SgVariableDefinition> {
33360 using node = SgVariableDefinition;
33361 using base = SgDeclarationStatement;
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<>;
33366 using fields_t = mp::List<describe_field_t<SgVariableDefinition,SgInitializedName*,&SgVariableDefinition::p_vardefn>, describe_field_t<SgVariableDefinition,SgExpression*,&SgVariableDefinition::p_bitfield>>;
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;
33373 using field_type = SgInitializedName*;
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};
33382template <> struct describe_node_t<SgVariableSymbol> {
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};
33388 using subclasses_t = mp::List<SgTemplateVariableSymbol>;
33389 using fields_t = mp::List<describe_field_t<SgVariableSymbol,SgInitializedName*,&SgVariableSymbol::p_declaration>>;
33390};
33391template <> struct node_from_variant_t<841> { using type = SgVariableSymbol; };
33392
33393// Class: VariantExpression
33394template <> struct describe_node_t<SgVariantExpression> {
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
33406template <> struct describe_node_t<SgVariantStatement> {
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
33430template <> struct describe_node_t<SgWaitStatement> {
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
33442template <> struct describe_node_t<SgWarningDirectiveStatement> {
33443 using node = SgWarningDirectiveStatement;
33444 using base = SgC_PreprocessorDirectiveStatement;
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};
33476template <> struct describe_node_t<SgWithStatement> {
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<>;
33483 using fields_t = mp::List<describe_field_t<SgWithStatement,SgExpression*,&SgWithStatement::p_expression>, describe_field_t<SgWithStatement,SgStatement*,&SgWithStatement::p_body>>;
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<>;
33517 using fields_t = mp::List<describe_field_t<SgWcharVal,unsigned long,&SgWcharVal::p_valueUL>, describe_field_t<SgWcharVal,std::string,&SgWcharVal::p_valueString>>;
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;
33546 using field_type = SgElseWhereStatement*;
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
33600template <> struct describe_field_t<SgWhileStmt,SgStatement*,&SgWhileStmt::p_condition> {
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};
33611template <> struct describe_field_t<SgWhileStmt,SgStatement*,&SgWhileStmt::p_body> {
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};
33622template <> struct describe_field_t<SgWhileStmt,SgStatement*,&SgWhileStmt::p_else_body> {
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};
33854template <> struct describe_node_t<SgWriteStatement> {
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<>;
33861 using fields_t = mp::List<describe_field_t<SgWriteStatement,SgExpression*,&SgWriteStatement::p_format>, describe_field_t<SgWriteStatement,SgExpression*,&SgWriteStatement::p_namelist>, describe_field_t<SgWriteStatement,SgExpression*,&SgWriteStatement::p_advance>, describe_field_t<SgWriteStatement,SgExpression*,&SgWriteStatement::p_asynchronous>, describe_field_t<SgWriteStatement,SgExpression*,&SgWriteStatement::p_blank>, describe_field_t<SgWriteStatement,SgExpression*,&SgWriteStatement::p_decimal>, describe_field_t<SgWriteStatement,SgExpression*,&SgWriteStatement::p_delim>, describe_field_t<SgWriteStatement,SgExpression*,&SgWriteStatement::p_end>, describe_field_t<SgWriteStatement,SgExpression*,&SgWriteStatement::p_eor>, describe_field_t<SgWriteStatement,SgExpression*,&SgWriteStatement::p_id>, describe_field_t<SgWriteStatement,SgExpression*,&SgWriteStatement::p_pad>, describe_field_t<SgWriteStatement,SgExpression*,&SgWriteStatement::p_pos>, describe_field_t<SgWriteStatement,SgExpression*,&SgWriteStatement::p_rec>, describe_field_t<SgWriteStatement,SgExpression*,&SgWriteStatement::p_round>, describe_field_t<SgWriteStatement,SgExpression*,&SgWriteStatement::p_sign>, describe_field_t<SgWriteStatement,SgExpression*,&SgWriteStatement::p_size>>;
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};
33889template <> struct describe_node_t<SgYieldExpression> {
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<>;
33896 using fields_t = mp::List<describe_field_t<SgYieldExpression,SgExpression*,&SgYieldExpression::p_value>>;
33897};
33898template <> struct node_from_variant_t<853> { using type = SgYieldExpression; };
33899
33900// Class: _File_Info
33901template <> struct describe_field_t<Sg_File_Info,int,&Sg_File_Info::p_file_id> {
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};
33912template <> struct describe_field_t<Sg_File_Info,int,&Sg_File_Info::p_line> {
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};
33923template <> struct describe_field_t<Sg_File_Info,int,&Sg_File_Info::p_col> {
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};
33934template <> struct describe_field_t<Sg_File_Info,unsigned int,&Sg_File_Info::p_classificationBitField> {
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};
33978template <> struct describe_field_t<Sg_File_Info,SgFileIdList,&Sg_File_Info::p_fileIDsToUnparse> {
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> {
34025 using parent = SgCAFWithTeamStatement;
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> {
34036 using parent = SgCAFWithTeamStatement;
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> {
34047 using parent = SgCAFWithTeamStatement;
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};
34057template <> struct describe_node_t<SgCAFWithTeamStatement> {
34058 using node = SgCAFWithTeamStatement;
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<>;
34064 using fields_t = mp::List<describe_field_t<SgCAFWithTeamStatement,SgVarRefExp*,&SgCAFWithTeamStatement::p_teamId>, describe_field_t<SgCAFWithTeamStatement,SgBasicBlock*,&SgCAFWithTeamStatement::p_body>, describe_field_t<SgCAFWithTeamStatement,bool,&SgCAFWithTeamStatement::p_endHasTeamId>>;
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};
34102template <> struct describe_node_t<SgCAFCoExpression> {
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<>;
34109 using fields_t = mp::List<describe_field_t<SgCAFCoExpression,SgVarRefExp*,&SgCAFCoExpression::p_teamId>, describe_field_t<SgCAFCoExpression,SgExpression*,&SgCAFCoExpression::p_teamRank>, describe_field_t<SgCAFCoExpression,SgExpression*,&SgCAFCoExpression::p_referData>>;
34110};
34111template <> struct node_from_variant_t<857> { using type = SgCAFCoExpression; };
34112
34113// Class: CallExpression
34114template <> struct describe_field_t<SgCallExpression,SgExpression*,&SgCallExpression::p_function> {
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};
34125template <> struct describe_field_t<SgCallExpression,SgExprListExp*,&SgCallExpression::p_args> {
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};
34136template <> struct describe_field_t<SgCallExpression,SgType*,&SgCallExpression::p_expression_type> {
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};
34147template <> struct describe_node_t<SgCallExpression> {
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};
34153 using subclasses_t = mp::List<SgFunctionCallExp>;
34154 using fields_t = mp::List<describe_field_t<SgCallExpression,SgExpression*,&SgCallExpression::p_function>, describe_field_t<SgCallExpression,SgExprListExp*,&SgCallExpression::p_args>, describe_field_t<SgCallExpression,SgType*,&SgCallExpression::p_expression_type>>;
34155};
34156template <> struct node_from_variant_t<858> { using type = SgCallExpression; };
34157
34158// Class: TypeCrayPointer
34159template <> struct describe_node_t<SgTypeCrayPointer> {
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> {
34172 using parent = SgJavaImportStatement;
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> {
34183 using parent = SgJavaImportStatement;
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};
34193template <> struct describe_node_t<SgJavaImportStatement> {
34194 using node = SgJavaImportStatement;
34195 using base = SgDeclarationStatement;
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<>;
34200 using fields_t = mp::List<describe_field_t<SgJavaImportStatement,SgName,&SgJavaImportStatement::p_path>, describe_field_t<SgJavaImportStatement,bool,&SgJavaImportStatement::p_containsWildCard>>;
34201};
34202template <> struct node_from_variant_t<860> { using type = SgJavaImportStatement; };
34203
34204// Class: JavaPackageDeclaration
34205template <> struct describe_node_t<SgJavaPackageDeclaration> {
34206 using node = SgJavaPackageDeclaration;
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> {
34218 using parent = SgJavaPackageStatement;
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};
34228template <> struct describe_node_t<SgJavaPackageStatement> {
34229 using node = SgJavaPackageStatement;
34230 using base = SgDeclarationStatement;
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<>;
34235 using fields_t = mp::List<describe_field_t<SgJavaPackageStatement,SgName,&SgJavaPackageStatement::p_name>>;
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> {
34241 using parent = SgJavaImportStatementList;
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};
34251template <> struct describe_node_t<SgJavaImportStatementList> {
34252 using node = SgJavaImportStatementList;
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<>;
34258 using fields_t = mp::List<describe_field_t<SgJavaImportStatementList,SgJavaImportStatementPtrList,&SgJavaImportStatementList::p_java_import_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> {
34264 using parent = SgJavaClassDeclarationList;
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};
34274template <> struct describe_node_t<SgJavaClassDeclarationList> {
34275 using node = SgJavaClassDeclarationList;
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<>;
34281 using fields_t = mp::List<describe_field_t<SgJavaClassDeclarationList,SgClassDeclarationPtrList,&SgJavaClassDeclarationList::p_java_class_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> {
34287 using parent = SgJavaMemberValuePair;
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> {
34298 using parent = SgJavaMemberValuePair;
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};
34308template <> struct describe_node_t<SgJavaMemberValuePair> {
34309 using node = SgJavaMemberValuePair;
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<>;
34315 using fields_t = mp::List<describe_field_t<SgJavaMemberValuePair,SgName,&SgJavaMemberValuePair::p_name>, describe_field_t<SgJavaMemberValuePair,SgExpression*,&SgJavaMemberValuePair::p_value>>;
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};
34331template <> struct describe_node_t<SgJavaAnnotation> {
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};
34337 using subclasses_t = mp::List<SgJavaMarkerAnnotation, SgJavaSingleMemberAnnotation, SgJavaNormalAnnotation>;
34338 using fields_t = mp::List<describe_field_t<SgJavaAnnotation,SgType*,&SgJavaAnnotation::p_expression_type>>;
34339};
34340template <> struct node_from_variant_t<866> { using type = SgJavaAnnotation; };
34341
34342// Class: JavaMarkerAnnotation
34343template <> struct describe_node_t<SgJavaMarkerAnnotation> {
34344 using node = SgJavaMarkerAnnotation;
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> {
34356 using parent = SgJavaSingleMemberAnnotation;
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};
34366template <> struct describe_node_t<SgJavaSingleMemberAnnotation> {
34367 using node = SgJavaSingleMemberAnnotation;
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<>;
34373 using fields_t = mp::List<describe_field_t<SgJavaSingleMemberAnnotation,SgExpression*,&SgJavaSingleMemberAnnotation::p_value>>;
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> {
34379 using parent = SgJavaNormalAnnotation;
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};
34389template <> struct describe_node_t<SgJavaNormalAnnotation> {
34390 using node = SgJavaNormalAnnotation;
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<>;
34396 using fields_t = mp::List<describe_field_t<SgJavaNormalAnnotation,SgJavaMemberValuePairPtrList,&SgJavaNormalAnnotation::p_value_pair_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> {
34402 using parent = SgJavaTypeExpression;
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};
34412template <> struct describe_node_t<SgJavaTypeExpression> {
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<>;
34419 using fields_t = mp::List<describe_field_t<SgJavaTypeExpression,SgType*,&SgJavaTypeExpression::p_type>>;
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> {
34425 using parent = SgJavaQualifiedType;
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> {
34436 using parent = SgJavaQualifiedType;
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};
34446template <> struct describe_node_t<SgJavaQualifiedType> {
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<>;
34453 using fields_t = mp::List<describe_field_t<SgJavaQualifiedType,SgNamedType *,&SgJavaQualifiedType::p_parent_type>, describe_field_t<SgJavaQualifiedType,SgNamedType *,&SgJavaQualifiedType::p_type>>;
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<>;
34487 using fields_t = mp::List<describe_field_t<SgClassExp,SgClassSymbol*,&SgClassExp::p_class_symbol>, describe_field_t<SgClassExp,int,&SgClassExp::p_pobj_class>>;
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};
34503template <> struct describe_node_t<SgJavaUnionType> {
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<>;
34510 using fields_t = mp::List<describe_field_t<SgJavaUnionType,SgTypePtrList,&SgJavaUnionType::p_type_list>>;
34511};
34512template <> struct node_from_variant_t<873> { using type = SgJavaUnionType; };
34513
34514// Class: JavaParameterType
34515template <> struct describe_node_t<SgJavaParameterType> {
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<>;
34545 using fields_t = mp::List<describe_field_t<SgAsyncStmt,SgStatement*,&SgAsyncStmt::p_body>>;
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<>;
34568 using fields_t = mp::List<describe_field_t<SgFinishStmt,SgStatement*,&SgFinishStmt::p_body>>;
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<>;
34602 using fields_t = mp::List<describe_field_t<SgAtStmt,SgExpression*,&SgAtStmt::p_expression>, describe_field_t<SgAtStmt,SgStatement*,&SgAtStmt::p_body>>;
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<>;
34625 using fields_t = mp::List<describe_field_t<SgAtomicStmt,SgStatement*,&SgAtomicStmt::p_body>>;
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<>;
34659 using fields_t = mp::List<describe_field_t<SgWhenStmt,SgExpression*,&SgWhenStmt::p_expression>, describe_field_t<SgWhenStmt,SgStatement*,&SgWhenStmt::p_body>>;
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<>;
34693 using fields_t = mp::List<describe_field_t<SgAtExp,SgExpression*,&SgAtExp::p_expression>, describe_field_t<SgAtExp,SgStatement*,&SgAtExp::p_body>>;
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<>;
34727 using fields_t = mp::List<describe_field_t<SgFinishExp,SgExpression*,&SgFinishExp::p_expression>, describe_field_t<SgFinishExp,SgStatement*,&SgFinishExp::p_body>>;
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<>;
34761 using fields_t = mp::List<describe_field_t<SgHereExp,SgType*,&SgHereExp::p_expression_type>, describe_field_t<SgHereExp,SgExpression*,&SgHereExp::p_expression>>;
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
34778template <> struct describe_node_t<SgAsmNullInstruction> {
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> {
34791 using parent = SgAdaComponentClause;
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> {
34802 using parent = SgAdaComponentClause;
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> {
34813 using parent = SgAdaComponentClause;
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};
34823template <> struct describe_node_t<SgAdaComponentClause> {
34824 using node = SgAdaComponentClause;
34825 using base = SgDeclarationStatement;
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<>;
34830 using fields_t = mp::List<describe_field_t<SgAdaComponentClause,SgVarRefExp*,&SgAdaComponentClause::p_component>, describe_field_t<SgAdaComponentClause,SgExpression*,&SgAdaComponentClause::p_offset>, describe_field_t<SgAdaComponentClause,SgRangeExp*,&SgAdaComponentClause::p_range>>;
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> {
34836 using parent = SgAdaIndexConstraint;
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};
34846template <> struct describe_node_t<SgAdaIndexConstraint> {
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<>;
34853 using fields_t = mp::List<describe_field_t<SgAdaIndexConstraint,SgExpressionPtrList,&SgAdaIndexConstraint::p_indexRanges>>;
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};
34869template <> struct describe_node_t<SgAdaModularType> {
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<>;
34876 using fields_t = mp::List<describe_field_t<SgAdaModularType,SgExpression*,&SgAdaModularType::p_modexpr>>;
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> {
34882 using parent = SgAdaRepresentationClause;
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> {
34893 using parent = SgAdaRepresentationClause;
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> {
34904 using parent = SgAdaRepresentationClause;
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> {
34927 using parent = SgAdaFunctionRenamingDecl;
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};
34937template <> struct describe_node_t<SgAdaFunctionRenamingDecl> {
34938 using node = SgAdaFunctionRenamingDecl;
34939 using base = SgFunctionDeclaration;
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<>;
34944 using fields_t = mp::List<describe_field_t<SgAdaFunctionRenamingDecl,SgExpression*,&SgAdaFunctionRenamingDecl::p_renamed_function>>;
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;
34951 using field_type = SgAdaSelectAlternativeStmt*;
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;
34962 using field_type = SgAdaSelectAlternativeStmt*;
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> {
35017 using parent = SgAdaSelectAlternativeStmt;
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> {
35028 using parent = SgAdaSelectAlternativeStmt;
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> {
35039 using parent = SgAdaSelectAlternativeStmt;
35040 using field_type = SgAdaSelectAlternativeStmt*;
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
35061template <> struct describe_node_t<SgAdaTerminateStmt> {
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
35073template <> struct describe_node_t<SgAsmAarch32Coprocessor> {
35074 using node = SgAsmAarch32Coprocessor;
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> {
35086 using parent = SgAdaAttributeClause;
35087 using field_type = SgAdaAttributeExp*;
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> {
35097 using parent = SgAdaAttributeClause;
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};
35107template <> struct describe_node_t<SgAdaAttributeClause> {
35108 using node = SgAdaAttributeClause;
35109 using base = SgDeclarationStatement;
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<>;
35114 using fields_t = mp::List<describe_field_t<SgAdaAttributeClause,SgAdaAttributeExp*,&SgAdaAttributeClause::p_attribute>, describe_field_t<SgAdaAttributeClause,SgExpression*,&SgAdaAttributeClause::p_size>>;
35115};
35116template <> struct node_from_variant_t<896> { using type = SgAdaAttributeClause; };
35117
35118// Class: AsmBinaryConcat
35119template <> struct describe_node_t<SgAsmBinaryConcat> {
35120 using node = SgAsmBinaryConcat;
35121 using base = SgAsmBinaryExpression;
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};
35154template <> struct describe_node_t<SgAdaDerivedType> {
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<>;
35161 using fields_t = mp::List<describe_field_t<SgAdaDerivedType,SgType*,&SgAdaDerivedType::p_base_type>>;
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> {
35223 using parent = SgAdaEnumRepresentationClause;
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> {
35234 using parent = SgAdaEnumRepresentationClause;
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};
35244template <> struct describe_node_t<SgAdaEnumRepresentationClause> {
35245 using node = SgAdaEnumRepresentationClause;
35246 using base = SgDeclarationStatement;
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<>;
35251 using fields_t = mp::List<describe_field_t<SgAdaEnumRepresentationClause,SgType*,&SgAdaEnumRepresentationClause::p_enumType>, describe_field_t<SgAdaEnumRepresentationClause,SgExprListExp*,&SgAdaEnumRepresentationClause::p_components>>;
35252};
35253template <> struct node_from_variant_t<901> { using type = SgAdaEnumRepresentationClause; };
35254
35255// Class: AsmBinaryPreupdate
35256template <> struct describe_node_t<SgAsmBinaryPreupdate> {
35257 using node = SgAsmBinaryPreupdate;
35258 using base = SgAsmBinaryExpression;
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
35268template <> struct describe_node_t<SgAsmBinaryPostupdate> {
35269 using node = SgAsmBinaryPostupdate;
35270 using base = SgAsmBinaryExpression;
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> {
35293 using parent = SgAdaRenamingSymbol;
35294 using field_type = SgAdaRenamingDecl*;
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};
35303template <> struct describe_node_t<SgAdaRenamingSymbol> {
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<>;
35310 using fields_t = mp::List<describe_field_t<SgAdaRenamingSymbol,SgAdaRenamingDecl*,&SgAdaRenamingSymbol::p_declaration>>;
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> {
35316 using parent = SgAdaRenamingRefExp;
35317 using field_type = SgAdaRenamingSymbol*;
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};
35326template <> struct describe_node_t<SgAdaRenamingRefExp> {
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<>;
35333 using fields_t = mp::List<describe_field_t<SgAdaRenamingRefExp,SgAdaRenamingSymbol*,&SgAdaRenamingRefExp::p_symbol>>;
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;
35351 using field_type = SgAdaGenericDefn*;
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;
35362 using field_type = SgDeclarationStatement*;
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;
35373 using field_type = SgScopeStatement*;
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};
35405template <> struct describe_node_t<SgAdaGenericDefn> {
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<>;
35412 using fields_t = mp::List<describe_field_t<SgAdaGenericDefn,SgDeclarationStatementPtrList,&SgAdaGenericDefn::p_declarations>>;
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};
35439template <> struct describe_node_t<SgAdaFormalType> {
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<>;
35446 using fields_t = mp::List<describe_field_t<SgAdaFormalType,bool,&SgAdaFormalType::p_is_private>, describe_field_t<SgAdaFormalType,SgType*,&SgAdaFormalType::p_formal_type>>;
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;
35453 using field_type = SgDeclarationStatement*;
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};
35462template <> struct describe_node_t<SgAdaGenericSymbol> {
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<>;
35469 using fields_t = mp::List<describe_field_t<SgAdaGenericSymbol,SgDeclarationStatement*,&SgAdaGenericSymbol::p_declaration>>;
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> {
35475 using parent = SgAdaFormalTypeDecl;
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> {
35486 using parent = SgAdaFormalTypeDecl;
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> {
35497 using parent = SgAdaFormalTypeDecl;
35498 using field_type = SgAdaParameterList*;
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};
35507template <> struct describe_node_t<SgAdaFormalTypeDecl> {
35508 using node = SgAdaFormalTypeDecl;
35509 using base = SgDeclarationStatement;
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<>;
35514 using fields_t = mp::List<describe_field_t<SgAdaFormalTypeDecl,SgName,&SgAdaFormalTypeDecl::p_name>, describe_field_t<SgAdaFormalTypeDecl,SgAdaFormalType*,&SgAdaFormalTypeDecl::p_type>, describe_field_t<SgAdaFormalTypeDecl,SgAdaParameterList*,&SgAdaFormalTypeDecl::p_discriminants>>;
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};
35530template <> struct describe_node_t<SgAdaUnitRefExp> {
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<>;
35537 using fields_t = mp::List<describe_field_t<SgAdaUnitRefExp,SgSymbol*,&SgAdaUnitRefExp::p_symbol>>;
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> {
35543 using parent = SgAdaDiscriminatedTypeDecl;
35544 using field_type = SgDeclarationScope*;
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> {
35554 using parent = SgAdaDiscriminatedTypeDecl;
35555 using field_type = SgAdaParameterList*;
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> {
35565 using parent = SgAdaDiscriminatedTypeDecl;
35566 using field_type = SgDeclarationStatement*;
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> {
35576 using parent = SgAdaDiscriminatedTypeDecl;
35577 using field_type = SgAdaDiscriminatedType*;
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> {
35587 using parent = SgAdaDiscriminatedTypeDecl;
35588 using field_type = SgScopeStatement*;
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
35609template <> struct describe_node_t<SgAdaDiscriminatedType> {
35610 using node = SgAdaDiscriminatedType;
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> {
35622 using parent = SgAdaDiscriminantConstraint;
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};
35632template <> struct describe_node_t<SgAdaDiscriminantConstraint> {
35633 using node = SgAdaDiscriminantConstraint;
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<>;
35639 using fields_t = mp::List<describe_field_t<SgAdaDiscriminantConstraint,SgExpressionPtrList,&SgAdaDiscriminantConstraint::p_discriminants>>;
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> {
35645 using parent = SgAdaGenericInstanceDecl;
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> {
35656 using parent = SgAdaGenericInstanceDecl;
35657 using field_type = SgDeclarationStatement*;
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> {
35667 using parent = SgAdaGenericInstanceDecl;
35668 using field_type = SgScopeStatement*;
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> {
35678 using parent = SgAdaGenericInstanceDecl;
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> {
35689 using parent = SgAdaGenericInstanceDecl;
35690 using field_type = SgScopeStatement*;
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};
35722template <> struct describe_node_t<SgAdaUnscopedBlock> {
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<>;
35729 using fields_t = mp::List<describe_field_t<SgAdaUnscopedBlock,SgStatementPtrList,&SgAdaUnscopedBlock::p_statements>>;
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> {
35735 using parent = SgAdaInheritedFunctionSymbol;
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> {
35746 using parent = SgAdaInheritedFunctionSymbol;
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> {
35757 using parent = SgAdaInheritedFunctionSymbol;
35758 using field_type = SgFunctionSymbol*;
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;
35781 using field_type = SgAdaProtectedSpec*;
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};
35801template <> struct describe_node_t<SgAdaProtectedBody> {
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<>;
35808 using fields_t = mp::List<describe_field_t<SgAdaProtectedBody,SgAdaProtectedSpec*,&SgAdaProtectedBody::p_spec>, describe_field_t<SgAdaProtectedBody,SgStatementPtrList,&SgAdaProtectedBody::p_statements>>;
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> {
35814 using parent = SgAdaProtectedBodyDecl;
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> {
35825 using parent = SgAdaProtectedBodyDecl;
35826 using field_type = SgDeclarationStatement*;
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> {
35836 using parent = SgAdaProtectedBodyDecl;
35837 using field_type = SgAdaProtectedBody*;
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;
35860 using field_type = SgAdaProtectedBody*;
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};
35891template <> struct describe_node_t<SgAdaProtectedSpec> {
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<>;
35898 using fields_t = mp::List<describe_field_t<SgAdaProtectedSpec,SgAdaProtectedBody*,&SgAdaProtectedSpec::p_body>, describe_field_t<SgAdaProtectedSpec,SgDeclarationStatementPtrList,&SgAdaProtectedSpec::p_declarations>, describe_field_t<SgAdaProtectedSpec,bool,&SgAdaProtectedSpec::p_hasPrivate>>;
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> {
35904 using parent = SgAdaProtectedSpecDecl;
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> {
35915 using parent = SgAdaProtectedSpecDecl;
35916 using field_type = SgAdaProtectedSpec*;
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> {
35926 using parent = SgAdaProtectedSpecDecl;
35927 using field_type = SgAdaProtectedType*;
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};
35936template <> struct describe_node_t<SgAdaProtectedSpecDecl> {
35937 using node = SgAdaProtectedSpecDecl;
35938 using base = SgDeclarationStatement;
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<>;
35943 using fields_t = mp::List<describe_field_t<SgAdaProtectedSpecDecl,SgName,&SgAdaProtectedSpecDecl::p_name>, describe_field_t<SgAdaProtectedSpecDecl,SgAdaProtectedSpec*,&SgAdaProtectedSpecDecl::p_definition>, describe_field_t<SgAdaProtectedSpecDecl,SgAdaProtectedType*,&SgAdaProtectedSpecDecl::p_type>>;
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> {
35949 using parent = SgAdaProtectedSymbol;
35950 using field_type = SgDeclarationStatement*;
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};
35959template <> struct describe_node_t<SgAdaProtectedSymbol> {
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<>;
35966 using fields_t = mp::List<describe_field_t<SgAdaProtectedSymbol,SgDeclarationStatement*,&SgAdaProtectedSymbol::p_declaration>>;
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> {
35972 using parent = SgAdaProtectedRefExp;
35973 using field_type = SgAdaProtectedSymbol*;
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};
35982template <> struct describe_node_t<SgAdaProtectedRefExp> {
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<>;
35989 using fields_t = mp::List<describe_field_t<SgAdaProtectedRefExp,SgAdaProtectedSymbol*,&SgAdaProtectedRefExp::p_symbol>>;
35990};
35991template <> struct node_from_variant_t<924> { using type = SgAdaProtectedRefExp; };
35992
35993// Class: AdaProtectedType
35994template <> struct describe_node_t<SgAdaProtectedType> {
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> {
36007 using parent = SgAdaProtectedTypeDecl;
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> {
36018 using parent = SgAdaProtectedTypeDecl;
36019 using field_type = SgAdaProtectedSpec*;
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> {
36029 using parent = SgAdaProtectedTypeDecl;
36030 using field_type = SgAdaProtectedType*;
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> {
36040 using parent = SgAdaProtectedTypeDecl;
36041 using field_type = SgScopeStatement*;
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> {
36063 using parent = SgAdaDigitsConstraint;
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> {
36074 using parent = SgAdaDigitsConstraint;
36075 using field_type = SgAdaTypeConstraint*;
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};
36084template <> struct describe_node_t<SgAdaDigitsConstraint> {
36085 using node = SgAdaDigitsConstraint;
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<>;
36091 using fields_t = mp::List<describe_field_t<SgAdaDigitsConstraint,SgExpression*,&SgAdaDigitsConstraint::p_digits>, describe_field_t<SgAdaDigitsConstraint,SgAdaTypeConstraint*,&SgAdaDigitsConstraint::p_subConstraint>>;
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> {
36097 using parent = SgAdaAncestorInitializer;
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};
36107template <> struct describe_node_t<SgAdaAncestorInitializer> {
36108 using node = SgAdaAncestorInitializer;
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<>;
36114 using fields_t = mp::List<describe_field_t<SgAdaAncestorInitializer,SgExpression*,&SgAdaAncestorInitializer::p_ancestor>>;
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> {
36120 using parent = SgAdaDeltaConstraint;
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> {
36131 using parent = SgAdaDeltaConstraint;
36132 using field_type = SgAdaTypeConstraint*;
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> {
36142 using parent = SgAdaDeltaConstraint;
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};
36152template <> struct describe_node_t<SgAdaDeltaConstraint> {
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<>;
36159 using fields_t = mp::List<describe_field_t<SgAdaDeltaConstraint,SgExpression*,&SgAdaDeltaConstraint::p_delta>, describe_field_t<SgAdaDeltaConstraint,SgAdaTypeConstraint*,&SgAdaDeltaConstraint::p_subConstraint>, describe_field_t<SgAdaDeltaConstraint,bool,&SgAdaDeltaConstraint::p_isDecimal>>;
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> {
36165 using parent = SgAdaSubroutineType;
36166 using field_type = SgFunctionParameterList*;
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> {
36176 using parent = SgAdaSubroutineType;
36177 using field_type = SgFunctionParameterScope*;
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> {
36187 using parent = SgAdaSubroutineType;
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> {
36198 using parent = SgAdaSubroutineType;
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> {
36221 using parent = SgAdaGenericInstanceSymbol;
36222 using field_type = SgAdaGenericInstanceDecl*;
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};
36231template <> struct describe_node_t<SgAdaGenericInstanceSymbol> {
36232 using node = SgAdaGenericInstanceSymbol;
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<>;
36238 using fields_t = mp::List<describe_field_t<SgAdaGenericInstanceSymbol,SgAdaGenericInstanceDecl*,&SgAdaGenericInstanceSymbol::p_declaration>>;
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> {
36244 using parent = SgAdaFormalPackageDecl;
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> {
36255 using parent = SgAdaFormalPackageDecl;
36256 using field_type = SgDeclarationStatement*;
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> {
36266 using parent = SgAdaFormalPackageDecl;
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> {
36277 using parent = SgAdaFormalPackageDecl;
36278 using field_type = SgDeclarationStatement*;
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> {
36288 using parent = SgAdaFormalPackageDecl;
36289 using field_type = SgScopeStatement*;
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> {
36311 using parent = SgAdaFormalPackageSymbol;
36312 using field_type = SgAdaFormalPackageDecl*;
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};
36321template <> struct describe_node_t<SgAdaFormalPackageSymbol> {
36322 using node = SgAdaFormalPackageSymbol;
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<>;
36328 using fields_t = mp::List<describe_field_t<SgAdaFormalPackageSymbol,SgAdaFormalPackageDecl*,&SgAdaFormalPackageSymbol::p_declaration>>;
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> {
36334 using parent = SgAsmJvmAttributeTable;
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};
36344template <> struct describe_node_t<SgAsmJvmAttributeTable> {
36345 using node = SgAsmJvmAttributeTable;
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<>;
36351 using fields_t = mp::List<describe_field_t<SgAsmJvmAttributeTable,SgAsmJvmAttributePtrList,&SgAsmJvmAttributeTable::p_attributes>>;
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> {
36357 using parent = SgAsmJvmMethodTable;
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};
36367template <> struct describe_node_t<SgAsmJvmMethodTable> {
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<>;
36374 using fields_t = mp::List<describe_field_t<SgAsmJvmMethodTable,SgAsmJvmMethodPtrList,&SgAsmJvmMethodTable::p_methods>>;
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;
36414 using field_type = SgAsmJvmAttributeTable*;
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};
36446template <> struct describe_node_t<SgAsmJvmFieldTable> {
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<>;
36453 using fields_t = mp::List<describe_field_t<SgAsmJvmFieldTable,SgAsmJvmFieldPtrList,&SgAsmJvmFieldTable::p_fields>>;
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> {
36459 using parent = SgAsmJvmExceptionHandler;
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> {
36470 using parent = SgAsmJvmExceptionHandler;
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> {
36481 using parent = SgAsmJvmExceptionHandler;
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> {
36492 using parent = SgAsmJvmExceptionHandler;
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> {
36515 using parent = SgAsmJvmExceptionTable;
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};
36525template <> struct describe_node_t<SgAsmJvmExceptionTable> {
36526 using node = SgAsmJvmExceptionTable;
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<>;
36532 using fields_t = mp::List<describe_field_t<SgAsmJvmExceptionTable,SgAsmJvmExceptionHandlerPtrList,&SgAsmJvmExceptionTable::p_handlers>>;
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> {
36550 using parent = SgAsmJvmLineNumberEntry;
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> {
36561 using parent = SgAsmJvmLineNumberEntry;
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};
36571template <> struct describe_node_t<SgAsmJvmLineNumberEntry> {
36572 using node = SgAsmJvmLineNumberEntry;
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<>;
36578 using fields_t = mp::List<describe_field_t<SgAsmJvmLineNumberEntry,uint16_t,&SgAsmJvmLineNumberEntry::p_start_pc>, describe_field_t<SgAsmJvmLineNumberEntry,uint16_t,&SgAsmJvmLineNumberEntry::p_line_number>>;
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> {
36584 using parent = SgAsmJvmLineNumberTable;
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};
36594template <> struct describe_node_t<SgAsmJvmLineNumberTable> {
36595 using node = SgAsmJvmLineNumberTable;
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<>;
36601 using fields_t = mp::List<describe_field_t<SgAsmJvmLineNumberTable,SgAsmJvmLineNumberEntryPtrList,&SgAsmJvmLineNumberTable::p_line_number_table>>;
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> {
36607 using parent = SgAsmJvmInnerClassesEntry;
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> {
36618 using parent = SgAsmJvmInnerClassesEntry;
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> {
36629 using parent = SgAsmJvmInnerClassesEntry;
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> {
36640 using parent = SgAsmJvmInnerClassesEntry;
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> {
36663 using parent = SgAsmJvmInnerClasses;
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};
36673template <> struct describe_node_t<SgAsmJvmInnerClasses> {
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<>;
36680 using fields_t = mp::List<describe_field_t<SgAsmJvmInnerClasses,SgAsmJvmInnerClassesEntryPtrList,&SgAsmJvmInnerClasses::p_classes>>;
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> {
36686 using parent = SgAsmCilInstruction;
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};
36696template <> struct describe_node_t<SgAsmCilInstruction> {
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<>;
36703 using fields_t = mp::List<describe_field_t<SgAsmCilInstruction,Rose::BinaryAnalysis::CilInstructionKind,&SgAsmCilInstruction::p_kind>>;
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> {
36709 using parent = SgAsmStackExpression;
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};
36719template <> struct describe_node_t<SgAsmStackExpression> {
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<>;
36726 using fields_t = mp::List<describe_field_t<SgAsmStackExpression,int,&SgAsmStackExpression::p_stackPosition>>;
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> {
36732 using parent = SgAsmJvmEnclosingMethod;
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> {
36743 using parent = SgAsmJvmEnclosingMethod;
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};
36753template <> struct describe_node_t<SgAsmJvmEnclosingMethod> {
36754 using node = SgAsmJvmEnclosingMethod;
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<>;
36760 using fields_t = mp::List<describe_field_t<SgAsmJvmEnclosingMethod,uint16_t,&SgAsmJvmEnclosingMethod::p_class_index>, describe_field_t<SgAsmJvmEnclosingMethod,uint16_t,&SgAsmJvmEnclosingMethod::p_method_index>>;
36761};
36762template <> struct node_from_variant_t<947> { using type = SgAsmJvmEnclosingMethod; };
36763
36764// Class: AdaNullConstraint
36765template <> struct describe_node_t<SgAdaNullConstraint> {
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> {
36778 using parent = SgAsmJvmModuleMainClass;
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};
36788template <> struct describe_node_t<SgAsmJvmModuleMainClass> {
36789 using node = SgAsmJvmModuleMainClass;
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<>;
36795 using fields_t = mp::List<describe_field_t<SgAsmJvmModuleMainClass,uint16_t,&SgAsmJvmModuleMainClass::p_main_class_index>>;
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> {
36801 using parent = SgAsmInstructionList;
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};
36811template <> struct describe_node_t<SgAsmInstructionList> {
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<>;
36818 using fields_t = mp::List<describe_field_t<SgAsmInstructionList,SgAsmInstructionPtrList,&SgAsmInstructionList::p_instructions>>;
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};
36829 using subclasses_t = mp::List<SgAsmCilDataStream, SgAsmCilExceptionData, SgAsmCilMetadata, SgAsmCilMetadataRoot, SgAsmCilMethodData>;
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};
36979template <> struct describe_node_t<SgAsmCilAssemblyOS> {
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<>;
36986 using fields_t = mp::List<describe_field_t<SgAsmCilAssemblyOS,uint32_t,&SgAsmCilAssemblyOS::p_OSPlatformID>, describe_field_t<SgAsmCilAssemblyOS,uint32_t,&SgAsmCilAssemblyOS::p_OSMajorVersion>, describe_field_t<SgAsmCilAssemblyOS,uint32_t,&SgAsmCilAssemblyOS::p_OSMinorVersion>>;
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> {
36992 using parent = SgAsmCilAssemblyProcessor;
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};
37002template <> struct describe_node_t<SgAsmCilAssemblyProcessor> {
37003 using node = SgAsmCilAssemblyProcessor;
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<>;
37009 using fields_t = mp::List<describe_field_t<SgAsmCilAssemblyProcessor,uint32_t,&SgAsmCilAssemblyProcessor::p_Processor>>;
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> {
37015 using parent = SgAsmCilAssemblyRef;
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> {
37026 using parent = SgAsmCilAssemblyRef;
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> {
37037 using parent = SgAsmCilAssemblyRef;
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> {
37048 using parent = SgAsmCilAssemblyRef;
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> {
37059 using parent = SgAsmCilAssemblyRef;
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> {
37070 using parent = SgAsmCilAssemblyRef;
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> {
37081 using parent = SgAsmCilAssemblyRef;
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> {
37092 using parent = SgAsmCilAssemblyRef;
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> {
37103 using parent = SgAsmCilAssemblyRef;
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> {
37126 using parent = SgAsmCilAssemblyRefOS;
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> {
37137 using parent = SgAsmCilAssemblyRefOS;
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> {
37148 using parent = SgAsmCilAssemblyRefOS;
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> {
37159 using parent = SgAsmCilAssemblyRefOS;
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> {
37182 using parent = SgAsmCilAssemblyRefProcessor;
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> {
37193 using parent = SgAsmCilAssemblyRefProcessor;
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};
37203template <> struct describe_node_t<SgAsmCilAssemblyRefProcessor> {
37204 using node = SgAsmCilAssemblyRefProcessor;
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<>;
37210 using fields_t = mp::List<describe_field_t<SgAsmCilAssemblyRefProcessor,uint32_t,&SgAsmCilAssemblyRefProcessor::p_Processor>, describe_field_t<SgAsmCilAssemblyRefProcessor,uint32_t,&SgAsmCilAssemblyRefProcessor::p_AssemblyRef>>;
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> {
37216 using parent = SgAsmCilClassLayout;
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> {
37227 using parent = SgAsmCilClassLayout;
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> {
37238 using parent = SgAsmCilClassLayout;
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};
37248template <> struct describe_node_t<SgAsmCilClassLayout> {
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<>;
37255 using fields_t = mp::List<describe_field_t<SgAsmCilClassLayout,uint16_t,&SgAsmCilClassLayout::p_PackingSize>, describe_field_t<SgAsmCilClassLayout,uint32_t,&SgAsmCilClassLayout::p_ClassSize>, describe_field_t<SgAsmCilClassLayout,uint32_t,&SgAsmCilClassLayout::p_Parent>>;
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};
37304template <> struct describe_node_t<SgAsmCilConstant> {
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<>;
37311 using fields_t = mp::List<describe_field_t<SgAsmCilConstant,uint8_t,&SgAsmCilConstant::p_Type>, describe_field_t<SgAsmCilConstant,uint8_t,&SgAsmCilConstant::p_Padding>, describe_field_t<SgAsmCilConstant,uint32_t,&SgAsmCilConstant::p_Parent>, describe_field_t<SgAsmCilConstant,uint32_t,&SgAsmCilConstant::p_Value>>;
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> {
37317 using parent = SgAsmCilCustomAttribute;
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> {
37328 using parent = SgAsmCilCustomAttribute;
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> {
37339 using parent = SgAsmCilCustomAttribute;
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};
37349template <> struct describe_node_t<SgAsmCilCustomAttribute> {
37350 using node = SgAsmCilCustomAttribute;
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<>;
37356 using fields_t = mp::List<describe_field_t<SgAsmCilCustomAttribute,uint32_t,&SgAsmCilCustomAttribute::p_Parent>, describe_field_t<SgAsmCilCustomAttribute,uint32_t,&SgAsmCilCustomAttribute::p_Type>, describe_field_t<SgAsmCilCustomAttribute,uint32_t,&SgAsmCilCustomAttribute::p_Value>>;
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> {
37362 using parent = SgAsmCilDeclSecurity;
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> {
37373 using parent = SgAsmCilDeclSecurity;
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> {
37384 using parent = SgAsmCilDeclSecurity;
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};
37394template <> struct describe_node_t<SgAsmCilDeclSecurity> {
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<>;
37401 using fields_t = mp::List<describe_field_t<SgAsmCilDeclSecurity,uint16_t,&SgAsmCilDeclSecurity::p_Action>, describe_field_t<SgAsmCilDeclSecurity,uint32_t,&SgAsmCilDeclSecurity::p_Parent>, describe_field_t<SgAsmCilDeclSecurity,uint32_t,&SgAsmCilDeclSecurity::p_PermissionSet>>;
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<>;
37446 using fields_t = mp::List<describe_field_t<SgAsmCilEvent,uint16_t,&SgAsmCilEvent::p_EventFlags>, describe_field_t<SgAsmCilEvent,uint32_t,&SgAsmCilEvent::p_Name>, describe_field_t<SgAsmCilEvent,uint32_t,&SgAsmCilEvent::p_EventType>>;
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};
37473template <> struct describe_node_t<SgAsmCilEventMap> {
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<>;
37480 using fields_t = mp::List<describe_field_t<SgAsmCilEventMap,uint32_t,&SgAsmCilEventMap::p_Parent>, describe_field_t<SgAsmCilEventMap,uint32_t,&SgAsmCilEventMap::p_EventList>>;
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> {
37486 using parent = SgAsmCilExportedType;
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> {
37497 using parent = SgAsmCilExportedType;
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> {
37508 using parent = SgAsmCilExportedType;
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> {
37519 using parent = SgAsmCilExportedType;
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> {
37530 using parent = SgAsmCilExportedType;
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<>;
37592 using fields_t = mp::List<describe_field_t<SgAsmCilField,uint16_t,&SgAsmCilField::p_Flags>, describe_field_t<SgAsmCilField,uint32_t,&SgAsmCilField::p_Name>, describe_field_t<SgAsmCilField,uint32_t,&SgAsmCilField::p_Signature>>;
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> {
37598 using parent = SgAsmCilFieldLayout;
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> {
37609 using parent = SgAsmCilFieldLayout;
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};
37619template <> struct describe_node_t<SgAsmCilFieldLayout> {
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<>;
37626 using fields_t = mp::List<describe_field_t<SgAsmCilFieldLayout,uint32_t,&SgAsmCilFieldLayout::p_Offset>, describe_field_t<SgAsmCilFieldLayout,uint32_t,&SgAsmCilFieldLayout::p_Field>>;
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> {
37632 using parent = SgAsmCilFieldMarshal;
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> {
37643 using parent = SgAsmCilFieldMarshal;
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};
37653template <> struct describe_node_t<SgAsmCilFieldMarshal> {
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<>;
37660 using fields_t = mp::List<describe_field_t<SgAsmCilFieldMarshal,uint32_t,&SgAsmCilFieldMarshal::p_Parent>, describe_field_t<SgAsmCilFieldMarshal,uint32_t,&SgAsmCilFieldMarshal::p_NativeType>>;
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};
37687template <> struct describe_node_t<SgAsmCilFieldRVA> {
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<>;
37694 using fields_t = mp::List<describe_field_t<SgAsmCilFieldRVA,uint32_t,&SgAsmCilFieldRVA::p_RVA>, describe_field_t<SgAsmCilFieldRVA,uint32_t,&SgAsmCilFieldRVA::p_Field>>;
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<>;
37739 using fields_t = mp::List<describe_field_t<SgAsmCilFile,uint32_t,&SgAsmCilFile::p_Flags>, describe_field_t<SgAsmCilFile,uint32_t,&SgAsmCilFile::p_Name>, describe_field_t<SgAsmCilFile,uint32_t,&SgAsmCilFile::p_HashValue>>;
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> {
37745 using parent = SgAsmCilGenericParam;
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> {
37756 using parent = SgAsmCilGenericParam;
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> {
37767 using parent = SgAsmCilGenericParam;
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> {
37778 using parent = SgAsmCilGenericParam;
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> {
37801 using parent = SgAsmCilGenericParamConstraint;
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> {
37812 using parent = SgAsmCilGenericParamConstraint;
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};
37822template <> struct describe_node_t<SgAsmCilGenericParamConstraint> {
37823 using node = SgAsmCilGenericParamConstraint;
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<>;
37829 using fields_t = mp::List<describe_field_t<SgAsmCilGenericParamConstraint,uint32_t,&SgAsmCilGenericParamConstraint::p_Owner>, describe_field_t<SgAsmCilGenericParamConstraint,uint32_t,&SgAsmCilGenericParamConstraint::p_Constraint>>;
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> {
37891 using parent = SgAsmCilInterfaceImpl;
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> {
37902 using parent = SgAsmCilInterfaceImpl;
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};
37912template <> struct describe_node_t<SgAsmCilInterfaceImpl> {
37913 using node = SgAsmCilInterfaceImpl;
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<>;
37919 using fields_t = mp::List<describe_field_t<SgAsmCilInterfaceImpl,uint32_t,&SgAsmCilInterfaceImpl::p_Class>, describe_field_t<SgAsmCilInterfaceImpl,uint32_t,&SgAsmCilInterfaceImpl::p_Interface>>;
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> {
37925 using parent = SgAsmCilManifestResource;
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> {
37936 using parent = SgAsmCilManifestResource;
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> {
37947 using parent = SgAsmCilManifestResource;
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> {
37958 using parent = SgAsmCilManifestResource;
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};
38013template <> struct describe_node_t<SgAsmCilMemberRef> {
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<>;
38020 using fields_t = mp::List<describe_field_t<SgAsmCilMemberRef,uint32_t,&SgAsmCilMemberRef::p_Class>, describe_field_t<SgAsmCilMemberRef,uint32_t,&SgAsmCilMemberRef::p_Name>, describe_field_t<SgAsmCilMemberRef,uint32_t,&SgAsmCilMemberRef::p_Signature>>;
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};
38202template <> struct describe_node_t<SgAsmCilMethodImpl> {
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<>;
38209 using fields_t = mp::List<describe_field_t<SgAsmCilMethodImpl,uint32_t,&SgAsmCilMethodImpl::p_Class>, describe_field_t<SgAsmCilMethodImpl,uint32_t,&SgAsmCilMethodImpl::p_MethodBody>, describe_field_t<SgAsmCilMethodImpl,uint32_t,&SgAsmCilMethodImpl::p_MethodDeclaration>>;
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> {
38215 using parent = SgAsmCilMethodSemantics;
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> {
38226 using parent = SgAsmCilMethodSemantics;
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> {
38237 using parent = SgAsmCilMethodSemantics;
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};
38247template <> struct describe_node_t<SgAsmCilMethodSemantics> {
38248 using node = SgAsmCilMethodSemantics;
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<>;
38254 using fields_t = mp::List<describe_field_t<SgAsmCilMethodSemantics,uint16_t,&SgAsmCilMethodSemantics::p_Semantics>, describe_field_t<SgAsmCilMethodSemantics,uint32_t,&SgAsmCilMethodSemantics::p_Method>, describe_field_t<SgAsmCilMethodSemantics,uint32_t,&SgAsmCilMethodSemantics::p_Association>>;
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};
38281template <> struct describe_node_t<SgAsmCilMethodSpec> {
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<>;
38288 using fields_t = mp::List<describe_field_t<SgAsmCilMethodSpec,uint32_t,&SgAsmCilMethodSpec::p_Method>, describe_field_t<SgAsmCilMethodSpec,uint32_t,&SgAsmCilMethodSpec::p_Instantiation>>;
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};
38371template <> struct describe_node_t<SgAsmCilModuleRef> {
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<>;
38378 using fields_t = mp::List<describe_field_t<SgAsmCilModuleRef,uint32_t,&SgAsmCilModuleRef::p_Name>>;
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> {
38384 using parent = SgAsmCilNestedClass;
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> {
38395 using parent = SgAsmCilNestedClass;
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};
38405template <> struct describe_node_t<SgAsmCilNestedClass> {
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<>;
38412 using fields_t = mp::List<describe_field_t<SgAsmCilNestedClass,uint32_t,&SgAsmCilNestedClass::p_NestedClass>, describe_field_t<SgAsmCilNestedClass,uint32_t,&SgAsmCilNestedClass::p_EnclosingClass>>;
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<>;
38457 using fields_t = mp::List<describe_field_t<SgAsmCilParam,uint16_t,&SgAsmCilParam::p_Flags>, describe_field_t<SgAsmCilParam,uint16_t,&SgAsmCilParam::p_Sequence>, describe_field_t<SgAsmCilParam,uint32_t,&SgAsmCilParam::p_Name>>;
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};
38495template <> struct describe_node_t<SgAsmCilProperty> {
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<>;
38502 using fields_t = mp::List<describe_field_t<SgAsmCilProperty,uint16_t,&SgAsmCilProperty::p_Flags>, describe_field_t<SgAsmCilProperty,uint32_t,&SgAsmCilProperty::p_Name>, describe_field_t<SgAsmCilProperty,uint32_t,&SgAsmCilProperty::p_Type>>;
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> {
38508 using parent = SgAsmCilPropertyMap;
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> {
38519 using parent = SgAsmCilPropertyMap;
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};
38529template <> struct describe_node_t<SgAsmCilPropertyMap> {
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<>;
38536 using fields_t = mp::List<describe_field_t<SgAsmCilPropertyMap,uint32_t,&SgAsmCilPropertyMap::p_Parent>, describe_field_t<SgAsmCilPropertyMap,uint32_t,&SgAsmCilPropertyMap::p_PropertyList>>;
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> {
38542 using parent = SgAsmCilStandAloneSig;
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};
38552template <> struct describe_node_t<SgAsmCilStandAloneSig> {
38553 using node = SgAsmCilStandAloneSig;
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<>;
38559 using fields_t = mp::List<describe_field_t<SgAsmCilStandAloneSig,uint32_t,&SgAsmCilStandAloneSig::p_Signature>>;
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};
38675template <> struct describe_node_t<SgAsmCilTypeRef> {
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<>;
38682 using fields_t = mp::List<describe_field_t<SgAsmCilTypeRef,uint16_t,&SgAsmCilTypeRef::p_ResolutionScope>, describe_field_t<SgAsmCilTypeRef,uint32_t,&SgAsmCilTypeRef::p_TypeName>, describe_field_t<SgAsmCilTypeRef,uint32_t,&SgAsmCilTypeRef::p_TypeNamespace>>;
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};
38698template <> struct describe_node_t<SgAsmCilTypeSpec> {
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<>;
38705 using fields_t = mp::List<describe_field_t<SgAsmCilTypeSpec,uint32_t,&SgAsmCilTypeSpec::p_Signature>>;
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};
38721template <> struct describe_node_t<SgAdaParameterList> {
38722 using node = SgAdaParameterList;
38723 using base = SgDeclarationStatement;
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<>;
38728 using fields_t = mp::List<describe_field_t<SgAdaParameterList,SgDeclarationStatementPtrList,&SgAdaParameterList::p_parameters>>;
38729};
38730template <> struct node_from_variant_t<990> { using type = SgAdaParameterList; };
38731
38732// Class: AsmCilMetadata
38733template <> struct describe_node_t<SgAsmCilMetadata> {
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> {
38746 using parent = SgAsmCilMetadataRoot;
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> {
38757 using parent = SgAsmCilMetadataRoot;
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> {
38768 using parent = SgAsmCilMetadataRoot;
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> {
38779 using parent = SgAsmCilMetadataRoot;
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> {
38790 using parent = SgAsmCilMetadataRoot;
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> {
38801 using parent = SgAsmCilMetadataRoot;
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> {
38812 using parent = SgAsmCilMetadataRoot;
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> {
38823 using parent = SgAsmCilMetadataRoot;
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> {
38834 using parent = SgAsmCilMetadataRoot;
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> {
38845 using parent = SgAsmCilMetadataRoot;
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> {
38924 using parent = SgAsmCilMetadataHeap;
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> {
38935 using parent = SgAsmCilMetadataHeap;
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> {
38946 using parent = SgAsmCilMetadataHeap;
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> {
38957 using parent = SgAsmCilMetadataHeap;
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> {
38968 using parent = SgAsmCilMetadataHeap;
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> {
38979 using parent = SgAsmCilMetadataHeap;
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> {
38990 using parent = SgAsmCilMetadataHeap;
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> {
39001 using parent = SgAsmCilMetadataHeap;
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> {
39012 using parent = SgAsmCilMetadataHeap;
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> {
39023 using parent = SgAsmCilMetadataHeap;
39024 using field_type = SgAsmCilAssemblyTable*;
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> {
39034 using parent = SgAsmCilMetadataHeap;
39035 using field_type = SgAsmCilAssemblyOSTable*;
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> {
39045 using parent = SgAsmCilMetadataHeap;
39046 using field_type = SgAsmCilAssemblyProcessorTable*;
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> {
39056 using parent = SgAsmCilMetadataHeap;
39057 using field_type = SgAsmCilAssemblyRefTable*;
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> {
39067 using parent = SgAsmCilMetadataHeap;
39068 using field_type = SgAsmCilAssemblyRefOSTable*;
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> {
39078 using parent = SgAsmCilMetadataHeap;
39079 using field_type = SgAsmCilAssemblyRefProcessorTable*;
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> {
39089 using parent = SgAsmCilMetadataHeap;
39090 using field_type = SgAsmCilClassLayoutTable*;
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> {
39100 using parent = SgAsmCilMetadataHeap;
39101 using field_type = SgAsmCilConstantTable*;
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> {
39111 using parent = SgAsmCilMetadataHeap;
39112 using field_type = SgAsmCilCustomAttributeTable*;
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> {
39122 using parent = SgAsmCilMetadataHeap;
39123 using field_type = SgAsmCilDeclSecurityTable*;
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> {
39133 using parent = SgAsmCilMetadataHeap;
39134 using field_type = SgAsmCilEventTable*;
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> {
39144 using parent = SgAsmCilMetadataHeap;
39145 using field_type = SgAsmCilEventMapTable*;
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> {
39155 using parent = SgAsmCilMetadataHeap;
39156 using field_type = SgAsmCilExportedTypeTable*;
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> {
39166 using parent = SgAsmCilMetadataHeap;
39167 using field_type = SgAsmCilFieldTable*;
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> {
39177 using parent = SgAsmCilMetadataHeap;
39178 using field_type = SgAsmCilFieldLayoutTable*;
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> {
39188 using parent = SgAsmCilMetadataHeap;
39189 using field_type = SgAsmCilFieldMarshalTable*;
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> {
39199 using parent = SgAsmCilMetadataHeap;
39200 using field_type = SgAsmCilFieldRVATable*;
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> {
39210 using parent = SgAsmCilMetadataHeap;
39211 using field_type = SgAsmCilFileTable*;
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> {
39221 using parent = SgAsmCilMetadataHeap;
39222 using field_type = SgAsmCilGenericParamTable*;
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> {
39232 using parent = SgAsmCilMetadataHeap;
39233 using field_type = SgAsmCilGenericParamConstraintTable*;
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> {
39243 using parent = SgAsmCilMetadataHeap;
39244 using field_type = SgAsmCilImplMapTable*;
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> {
39254 using parent = SgAsmCilMetadataHeap;
39255 using field_type = SgAsmCilInterfaceImplTable*;
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> {
39265 using parent = SgAsmCilMetadataHeap;
39266 using field_type = SgAsmCilManifestResourceTable*;
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> {
39276 using parent = SgAsmCilMetadataHeap;
39277 using field_type = SgAsmCilMemberRefTable*;
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> {
39287 using parent = SgAsmCilMetadataHeap;
39288 using field_type = SgAsmCilMethodDefTable*;
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> {
39298 using parent = SgAsmCilMetadataHeap;
39299 using field_type = SgAsmCilMethodImplTable*;
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> {
39309 using parent = SgAsmCilMetadataHeap;
39310 using field_type = SgAsmCilMethodSemanticsTable*;
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> {
39320 using parent = SgAsmCilMetadataHeap;
39321 using field_type = SgAsmCilMethodSpecTable*;
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> {
39331 using parent = SgAsmCilMetadataHeap;
39332 using field_type = SgAsmCilModuleTable*;
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> {
39342 using parent = SgAsmCilMetadataHeap;
39343 using field_type = SgAsmCilModuleRefTable*;
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> {
39353 using parent = SgAsmCilMetadataHeap;
39354 using field_type = SgAsmCilNestedClassTable*;
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> {
39364 using parent = SgAsmCilMetadataHeap;
39365 using field_type = SgAsmCilParamTable*;
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> {
39375 using parent = SgAsmCilMetadataHeap;
39376 using field_type = SgAsmCilPropertyTable*;
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> {
39386 using parent = SgAsmCilMetadataHeap;
39387 using field_type = SgAsmCilPropertyMapTable*;
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> {
39397 using parent = SgAsmCilMetadataHeap;
39398 using field_type = SgAsmCilStandAloneSigTable*;
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> {
39408 using parent = SgAsmCilMetadataHeap;
39409 using field_type = SgAsmCilTypeDefTable*;
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> {
39419 using parent = SgAsmCilMetadataHeap;
39420 using field_type = SgAsmCilTypeRefTable*;
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> {
39430 using parent = SgAsmCilMetadataHeap;
39431 using field_type = SgAsmCilTypeSpecTable*;
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};
39440template <> struct describe_node_t<SgAsmCilMetadataHeap> {
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};
39463template <> struct describe_node_t<SgAsmCilUint8Heap> {
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<>;
39470 using fields_t = mp::List<describe_field_t<SgAsmCilUint8Heap,std::vector<uint8_t>,&SgAsmCilUint8Heap::p_Stream>>;
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};
39486template <> struct describe_node_t<SgAsmCilUint32Heap> {
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<>;
39493 using fields_t = mp::List<describe_field_t<SgAsmCilUint32Heap,std::vector<uint32_t>,&SgAsmCilUint32Heap::p_Stream>>;
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;
39632 using field_type = SgAsmCilMetadataRoot*;
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;
39666 using field_type = SgAdaUnscopedBlock*;
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};
39675template <> struct describe_node_t<SgAdaVariantDecl> {
39676 using node = SgAdaVariantDecl;
39677 using base = SgDeclarationStatement;
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<>;
39682 using fields_t = mp::List<describe_field_t<SgAdaVariantDecl,SgExpression*,&SgAdaVariantDecl::p_discriminant>, describe_field_t<SgAdaVariantDecl,SgAdaUnscopedBlock*,&SgAdaVariantDecl::p_variants>>;
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> {
39688 using parent = SgAdaVariantWhenStmt;
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> {
39699 using parent = SgAdaVariantWhenStmt;
39700 using field_type = SgAdaUnscopedBlock*;
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};
39709template <> struct describe_node_t<SgAdaVariantWhenStmt> {
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<>;
39716 using fields_t = mp::List<describe_field_t<SgAdaVariantWhenStmt,SgExprListExp*,&SgAdaVariantWhenStmt::p_choices>, describe_field_t<SgAdaVariantWhenStmt,SgAdaUnscopedBlock*,&SgAdaVariantWhenStmt::p_components>>;
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> {
39722 using parent = SgAsmCilAssemblyTable;
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};
39732template <> struct describe_node_t<SgAsmCilAssemblyTable> {
39733 using node = SgAsmCilAssemblyTable;
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<>;
39739 using fields_t = mp::List<describe_field_t<SgAsmCilAssemblyTable,std::vector<SgAsmCilAssembly*>,&SgAsmCilAssemblyTable::p_elements>>;
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> {
39745 using parent = SgAsmCilAssemblyOSTable;
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};
39755template <> struct describe_node_t<SgAsmCilAssemblyOSTable> {
39756 using node = SgAsmCilAssemblyOSTable;
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<>;
39762 using fields_t = mp::List<describe_field_t<SgAsmCilAssemblyOSTable,std::vector<SgAsmCilAssemblyOS*>,&SgAsmCilAssemblyOSTable::p_elements>>;
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> {
39768 using parent = SgAsmCilAssemblyProcessorTable;
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};
39778template <> struct describe_node_t<SgAsmCilAssemblyProcessorTable> {
39779 using node = SgAsmCilAssemblyProcessorTable;
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<>;
39785 using fields_t = mp::List<describe_field_t<SgAsmCilAssemblyProcessorTable,std::vector<SgAsmCilAssemblyProcessor*>,&SgAsmCilAssemblyProcessorTable::p_elements>>;
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> {
39791 using parent = SgAsmCilAssemblyRefTable;
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};
39801template <> struct describe_node_t<SgAsmCilAssemblyRefTable> {
39802 using node = SgAsmCilAssemblyRefTable;
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<>;
39808 using fields_t = mp::List<describe_field_t<SgAsmCilAssemblyRefTable,std::vector<SgAsmCilAssemblyRef*>,&SgAsmCilAssemblyRefTable::p_elements>>;
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> {
39814 using parent = SgAsmCilAssemblyRefOSTable;
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};
39824template <> struct describe_node_t<SgAsmCilAssemblyRefOSTable> {
39825 using node = SgAsmCilAssemblyRefOSTable;
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<>;
39831 using fields_t = mp::List<describe_field_t<SgAsmCilAssemblyRefOSTable,std::vector<SgAsmCilAssemblyRefOS*>,&SgAsmCilAssemblyRefOSTable::p_elements>>;
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> {
39837 using parent = SgAsmCilAssemblyRefProcessorTable;
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};
39847template <> struct describe_node_t<SgAsmCilAssemblyRefProcessorTable> {
39848 using node = SgAsmCilAssemblyRefProcessorTable;
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<>;
39854 using fields_t = mp::List<describe_field_t<SgAsmCilAssemblyRefProcessorTable,std::vector<SgAsmCilAssemblyRefProcessor*>,&SgAsmCilAssemblyRefProcessorTable::p_elements>>;
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> {
39860 using parent = SgAsmCilClassLayoutTable;
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};
39870template <> struct describe_node_t<SgAsmCilClassLayoutTable> {
39871 using node = SgAsmCilClassLayoutTable;
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<>;
39877 using fields_t = mp::List<describe_field_t<SgAsmCilClassLayoutTable,std::vector<SgAsmCilClassLayout*>,&SgAsmCilClassLayoutTable::p_elements>>;
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> {
39883 using parent = SgAsmCilConstantTable;
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};
39893template <> struct describe_node_t<SgAsmCilConstantTable> {
39894 using node = SgAsmCilConstantTable;
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<>;
39900 using fields_t = mp::List<describe_field_t<SgAsmCilConstantTable,std::vector<SgAsmCilConstant*>,&SgAsmCilConstantTable::p_elements>>;
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> {
39906 using parent = SgAsmCilCustomAttributeTable;
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};
39916template <> struct describe_node_t<SgAsmCilCustomAttributeTable> {
39917 using node = SgAsmCilCustomAttributeTable;
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<>;
39923 using fields_t = mp::List<describe_field_t<SgAsmCilCustomAttributeTable,std::vector<SgAsmCilCustomAttribute*>,&SgAsmCilCustomAttributeTable::p_elements>>;
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> {
39929 using parent = SgAsmCilDeclSecurityTable;
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};
39939template <> struct describe_node_t<SgAsmCilDeclSecurityTable> {
39940 using node = SgAsmCilDeclSecurityTable;
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<>;
39946 using fields_t = mp::List<describe_field_t<SgAsmCilDeclSecurityTable,std::vector<SgAsmCilDeclSecurity*>,&SgAsmCilDeclSecurityTable::p_elements>>;
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};
39962template <> struct describe_node_t<SgAsmCilEventTable> {
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<>;
39969 using fields_t = mp::List<describe_field_t<SgAsmCilEventTable,std::vector<SgAsmCilEvent*>,&SgAsmCilEventTable::p_elements>>;
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> {
39975 using parent = SgAsmCilEventMapTable;
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};
39985template <> struct describe_node_t<SgAsmCilEventMapTable> {
39986 using node = SgAsmCilEventMapTable;
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<>;
39992 using fields_t = mp::List<describe_field_t<SgAsmCilEventMapTable,std::vector<SgAsmCilEventMap*>,&SgAsmCilEventMapTable::p_elements>>;
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> {
39998 using parent = SgAsmCilExportedTypeTable;
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};
40008template <> struct describe_node_t<SgAsmCilExportedTypeTable> {
40009 using node = SgAsmCilExportedTypeTable;
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<>;
40015 using fields_t = mp::List<describe_field_t<SgAsmCilExportedTypeTable,std::vector<SgAsmCilExportedType*>,&SgAsmCilExportedTypeTable::p_elements>>;
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};
40031template <> struct describe_node_t<SgAsmCilFieldTable> {
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<>;
40038 using fields_t = mp::List<describe_field_t<SgAsmCilFieldTable,std::vector<SgAsmCilField*>,&SgAsmCilFieldTable::p_elements>>;
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> {
40044 using parent = SgAsmCilFieldLayoutTable;
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};
40054template <> struct describe_node_t<SgAsmCilFieldLayoutTable> {
40055 using node = SgAsmCilFieldLayoutTable;
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<>;
40061 using fields_t = mp::List<describe_field_t<SgAsmCilFieldLayoutTable,std::vector<SgAsmCilFieldLayout*>,&SgAsmCilFieldLayoutTable::p_elements>>;
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> {
40067 using parent = SgAsmCilFieldMarshalTable;
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};
40077template <> struct describe_node_t<SgAsmCilFieldMarshalTable> {
40078 using node = SgAsmCilFieldMarshalTable;
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<>;
40084 using fields_t = mp::List<describe_field_t<SgAsmCilFieldMarshalTable,std::vector<SgAsmCilFieldMarshal*>,&SgAsmCilFieldMarshalTable::p_elements>>;
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> {
40090 using parent = SgAsmCilFieldRVATable;
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};
40100template <> struct describe_node_t<SgAsmCilFieldRVATable> {
40101 using node = SgAsmCilFieldRVATable;
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<>;
40107 using fields_t = mp::List<describe_field_t<SgAsmCilFieldRVATable,std::vector<SgAsmCilFieldRVA*>,&SgAsmCilFieldRVATable::p_elements>>;
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};
40123template <> struct describe_node_t<SgAsmCilFileTable> {
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<>;
40130 using fields_t = mp::List<describe_field_t<SgAsmCilFileTable,std::vector<SgAsmCilFile*>,&SgAsmCilFileTable::p_elements>>;
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> {
40136 using parent = SgAsmCilGenericParamTable;
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};
40146template <> struct describe_node_t<SgAsmCilGenericParamTable> {
40147 using node = SgAsmCilGenericParamTable;
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<>;
40153 using fields_t = mp::List<describe_field_t<SgAsmCilGenericParamTable,std::vector<SgAsmCilGenericParam*>,&SgAsmCilGenericParamTable::p_elements>>;
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> {
40159 using parent = SgAsmCilGenericParamConstraintTable;
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};
40169template <> struct describe_node_t<SgAsmCilGenericParamConstraintTable> {
40170 using node = SgAsmCilGenericParamConstraintTable;
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<>;
40176 using fields_t = mp::List<describe_field_t<SgAsmCilGenericParamConstraintTable,std::vector<SgAsmCilGenericParamConstraint*>,&SgAsmCilGenericParamConstraintTable::p_elements>>;
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> {
40182 using parent = SgAsmCilImplMapTable;
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};
40192template <> struct describe_node_t<SgAsmCilImplMapTable> {
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<>;
40199 using fields_t = mp::List<describe_field_t<SgAsmCilImplMapTable,std::vector<SgAsmCilImplMap*>,&SgAsmCilImplMapTable::p_elements>>;
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> {
40205 using parent = SgAsmCilInterfaceImplTable;
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};
40215template <> struct describe_node_t<SgAsmCilInterfaceImplTable> {
40216 using node = SgAsmCilInterfaceImplTable;
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<>;
40222 using fields_t = mp::List<describe_field_t<SgAsmCilInterfaceImplTable,std::vector<SgAsmCilInterfaceImpl*>,&SgAsmCilInterfaceImplTable::p_elements>>;
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> {
40228 using parent = SgAsmCilManifestResourceTable;
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};
40238template <> struct describe_node_t<SgAsmCilManifestResourceTable> {
40239 using node = SgAsmCilManifestResourceTable;
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<>;
40245 using fields_t = mp::List<describe_field_t<SgAsmCilManifestResourceTable,std::vector<SgAsmCilManifestResource*>,&SgAsmCilManifestResourceTable::p_elements>>;
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> {
40251 using parent = SgAsmCilMemberRefTable;
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};
40261template <> struct describe_node_t<SgAsmCilMemberRefTable> {
40262 using node = SgAsmCilMemberRefTable;
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<>;
40268 using fields_t = mp::List<describe_field_t<SgAsmCilMemberRefTable,std::vector<SgAsmCilMemberRef*>,&SgAsmCilMemberRefTable::p_elements>>;
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> {
40274 using parent = SgAsmCilMethodDefTable;
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};
40284template <> struct describe_node_t<SgAsmCilMethodDefTable> {
40285 using node = SgAsmCilMethodDefTable;
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<>;
40291 using fields_t = mp::List<describe_field_t<SgAsmCilMethodDefTable,std::vector<SgAsmCilMethodDef*>,&SgAsmCilMethodDefTable::p_elements>>;
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> {
40297 using parent = SgAsmCilMethodImplTable;
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};
40307template <> struct describe_node_t<SgAsmCilMethodImplTable> {
40308 using node = SgAsmCilMethodImplTable;
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<>;
40314 using fields_t = mp::List<describe_field_t<SgAsmCilMethodImplTable,std::vector<SgAsmCilMethodImpl*>,&SgAsmCilMethodImplTable::p_elements>>;
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> {
40320 using parent = SgAsmCilMethodSemanticsTable;
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};
40330template <> struct describe_node_t<SgAsmCilMethodSemanticsTable> {
40331 using node = SgAsmCilMethodSemanticsTable;
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<>;
40337 using fields_t = mp::List<describe_field_t<SgAsmCilMethodSemanticsTable,std::vector<SgAsmCilMethodSemantics*>,&SgAsmCilMethodSemanticsTable::p_elements>>;
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> {
40343 using parent = SgAsmCilMethodSpecTable;
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};
40353template <> struct describe_node_t<SgAsmCilMethodSpecTable> {
40354 using node = SgAsmCilMethodSpecTable;
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<>;
40360 using fields_t = mp::List<describe_field_t<SgAsmCilMethodSpecTable,std::vector<SgAsmCilMethodSpec*>,&SgAsmCilMethodSpecTable::p_elements>>;
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> {
40366 using parent = SgAsmCilModuleTable;
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};
40376template <> struct describe_node_t<SgAsmCilModuleTable> {
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<>;
40383 using fields_t = mp::List<describe_field_t<SgAsmCilModuleTable,std::vector<SgAsmCilModule*>,&SgAsmCilModuleTable::p_elements>>;
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> {
40389 using parent = SgAsmCilModuleRefTable;
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};
40399template <> struct describe_node_t<SgAsmCilModuleRefTable> {
40400 using node = SgAsmCilModuleRefTable;
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<>;
40406 using fields_t = mp::List<describe_field_t<SgAsmCilModuleRefTable,std::vector<SgAsmCilModuleRef*>,&SgAsmCilModuleRefTable::p_elements>>;
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> {
40412 using parent = SgAsmCilNestedClassTable;
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};
40422template <> struct describe_node_t<SgAsmCilNestedClassTable> {
40423 using node = SgAsmCilNestedClassTable;
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<>;
40429 using fields_t = mp::List<describe_field_t<SgAsmCilNestedClassTable,std::vector<SgAsmCilNestedClass*>,&SgAsmCilNestedClassTable::p_elements>>;
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};
40445template <> struct describe_node_t<SgAsmCilParamTable> {
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<>;
40452 using fields_t = mp::List<describe_field_t<SgAsmCilParamTable,std::vector<SgAsmCilParam*>,&SgAsmCilParamTable::p_elements>>;
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> {
40458 using parent = SgAsmCilPropertyTable;
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};
40468template <> struct describe_node_t<SgAsmCilPropertyTable> {
40469 using node = SgAsmCilPropertyTable;
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<>;
40475 using fields_t = mp::List<describe_field_t<SgAsmCilPropertyTable,std::vector<SgAsmCilProperty*>,&SgAsmCilPropertyTable::p_elements>>;
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> {
40481 using parent = SgAsmCilPropertyMapTable;
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};
40491template <> struct describe_node_t<SgAsmCilPropertyMapTable> {
40492 using node = SgAsmCilPropertyMapTable;
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<>;
40498 using fields_t = mp::List<describe_field_t<SgAsmCilPropertyMapTable,std::vector<SgAsmCilPropertyMap*>,&SgAsmCilPropertyMapTable::p_elements>>;
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> {
40504 using parent = SgAsmCilStandAloneSigTable;
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};
40514template <> struct describe_node_t<SgAsmCilStandAloneSigTable> {
40515 using node = SgAsmCilStandAloneSigTable;
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<>;
40521 using fields_t = mp::List<describe_field_t<SgAsmCilStandAloneSigTable,std::vector<SgAsmCilStandAloneSig*>,&SgAsmCilStandAloneSigTable::p_elements>>;
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> {
40527 using parent = SgAsmCilTypeDefTable;
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};
40537template <> struct describe_node_t<SgAsmCilTypeDefTable> {
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<>;
40544 using fields_t = mp::List<describe_field_t<SgAsmCilTypeDefTable,std::vector<SgAsmCilTypeDef*>,&SgAsmCilTypeDefTable::p_elements>>;
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> {
40550 using parent = SgAsmCilTypeRefTable;
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};
40560template <> struct describe_node_t<SgAsmCilTypeRefTable> {
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<>;
40567 using fields_t = mp::List<describe_field_t<SgAsmCilTypeRefTable,std::vector<SgAsmCilTypeRef*>,&SgAsmCilTypeRefTable::p_elements>>;
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> {
40573 using parent = SgAsmCilTypeSpecTable;
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};
40583template <> struct describe_node_t<SgAsmCilTypeSpecTable> {
40584 using node = SgAsmCilTypeSpecTable;
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<>;
40590 using fields_t = mp::List<describe_field_t<SgAsmCilTypeSpecTable,std::vector<SgAsmCilTypeSpec*>,&SgAsmCilTypeSpecTable::p_elements>>;
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
40607template <> struct describe_node_t<SgFortranContinueStmt> {
40608 using node = SgFortranContinueStmt;
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> {
40620 using parent = SgAsmJvmStackMapTable;
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};
40630template <> struct describe_node_t<SgAsmJvmStackMapTable> {
40631 using node = SgAsmJvmStackMapTable;
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<>;
40637 using fields_t = mp::List<describe_field_t<SgAsmJvmStackMapTable,SgAsmJvmStackMapFramePtrList,&SgAsmJvmStackMapTable::p_entries>>;
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> {
40643 using parent = SgAsmJvmStackMapFrame;
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> {
40654 using parent = SgAsmJvmStackMapFrame;
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> {
40665 using parent = SgAsmJvmStackMapFrame;
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> {
40676 using parent = SgAsmJvmStackMapFrame;
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> {
40699 using parent = SgAsmJvmStackMapVerificationType;
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> {
40710 using parent = SgAsmJvmStackMapVerificationType;
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> {
40721 using parent = SgAsmJvmStackMapVerificationType;
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> {
40744 using parent = SgAsmJvmBootstrapMethod;
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> {
40755 using parent = SgAsmJvmBootstrapMethod;
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};
40765template <> struct describe_node_t<SgAsmJvmBootstrapMethod> {
40766 using node = SgAsmJvmBootstrapMethod;
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<>;
40772 using fields_t = mp::List<describe_field_t<SgAsmJvmBootstrapMethod,uint16_t,&SgAsmJvmBootstrapMethod::p_bootstrap_method_ref>, describe_field_t<SgAsmJvmBootstrapMethod,SgUnsigned16List,&SgAsmJvmBootstrapMethod::p_bootstrap_arguments>>;
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> {
40778 using parent = SgAsmJvmBootstrapMethods;
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};
40788template <> struct describe_node_t<SgAsmJvmBootstrapMethods> {
40789 using node = SgAsmJvmBootstrapMethods;
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<>;
40795 using fields_t = mp::List<describe_field_t<SgAsmJvmBootstrapMethods,SgAsmJvmBootstrapMethodPtrList,&SgAsmJvmBootstrapMethods::p_bootstrap_methods>>;
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};
40811template <> struct describe_node_t<SgAsmJvmExceptions> {
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<>;
40818 using fields_t = mp::List<describe_field_t<SgAsmJvmExceptions,SgUnsigned16List,&SgAsmJvmExceptions::p_exception_index_table>>;
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> {
40824 using parent = SgAsmJvmNestMembers;
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};
40834template <> struct describe_node_t<SgAsmJvmNestMembers> {
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<>;
40841 using fields_t = mp::List<describe_field_t<SgAsmJvmNestMembers,SgUnsigned16List,&SgAsmJvmNestMembers::p_classes>>;
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};
40857template <> struct describe_node_t<SgAsmJvmNestHost> {
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<>;
40864 using fields_t = mp::List<describe_field_t<SgAsmJvmNestHost,uint16_t,&SgAsmJvmNestHost::p_host_class_index>>;
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> {
40870 using parent = SgJovialLabelDeclaration;
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> {
40881 using parent = SgJovialLabelDeclaration;
40882 using field_type = SgJovialLabelDeclaration::label_type_enum;
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};
40891template <> struct describe_node_t<SgJovialLabelDeclaration> {
40892 using node = SgJovialLabelDeclaration;
40893 using base = SgDeclarationStatement;
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<>;
40898 using fields_t = mp::List<describe_field_t<SgJovialLabelDeclaration,std::string,&SgJovialLabelDeclaration::p_label>, describe_field_t<SgJovialLabelDeclaration,SgJovialLabelDeclaration::label_type_enum,&SgJovialLabelDeclaration::p_label_type>>;
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> {
40904 using parent = SgAsmJvmLocalVariableEntry;
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> {
40915 using parent = SgAsmJvmLocalVariableEntry;
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> {
40926 using parent = SgAsmJvmLocalVariableEntry;
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> {
40937 using parent = SgAsmJvmLocalVariableEntry;
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> {
40948 using parent = SgAsmJvmLocalVariableEntry;
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> {
40971 using parent = SgAsmJvmLocalVariableTable;
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};
40981template <> struct describe_node_t<SgAsmJvmLocalVariableTable> {
40982 using node = SgAsmJvmLocalVariableTable;
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<>;
40988 using fields_t = mp::List<describe_field_t<SgAsmJvmLocalVariableTable,SgAsmJvmLocalVariableEntryPtrList,&SgAsmJvmLocalVariableTable::p_local_variable_table>>;
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> {
40994 using parent = SgAsmJvmLocalVariableTypeEntry;
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> {
41005 using parent = SgAsmJvmLocalVariableTypeEntry;
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> {
41016 using parent = SgAsmJvmLocalVariableTypeEntry;
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> {
41027 using parent = SgAsmJvmLocalVariableTypeEntry;
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> {
41038 using parent = SgAsmJvmLocalVariableTypeEntry;
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> {
41061 using parent = SgAsmJvmLocalVariableTypeTable;
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};
41071template <> struct describe_node_t<SgAsmJvmLocalVariableTypeTable> {
41072 using node = SgAsmJvmLocalVariableTypeTable;
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<>;
41078 using fields_t = mp::List<describe_field_t<SgAsmJvmLocalVariableTypeTable,SgAsmJvmLocalVariableTypeEntryPtrList,&SgAsmJvmLocalVariableTypeTable::p_local_variable_type_table>>;
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> {
41084 using parent = SgAsmUserInstruction;
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};
41094template <> struct describe_node_t<SgAsmUserInstruction> {
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<>;
41101 using fields_t = mp::List<describe_field_t<SgAsmUserInstruction,unsigned,&SgAsmUserInstruction::p_kind>>;
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> {
41107 using parent = SgAsmJvmMethodParameters;
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};
41117template <> struct describe_node_t<SgAsmJvmMethodParameters> {
41118 using node = SgAsmJvmMethodParameters;
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<>;
41124 using fields_t = mp::List<describe_field_t<SgAsmJvmMethodParameters,SgAsmJvmMethodParametersEntryPtrList,&SgAsmJvmMethodParameters::p_parameters>>;
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> {
41130 using parent = SgAsmJvmMethodParametersEntry;
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> {
41141 using parent = SgAsmJvmMethodParametersEntry;
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};
41151template <> struct describe_node_t<SgAsmJvmMethodParametersEntry> {
41152 using node = SgAsmJvmMethodParametersEntry;
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<>;
41158 using fields_t = mp::List<describe_field_t<SgAsmJvmMethodParametersEntry,uint16_t,&SgAsmJvmMethodParametersEntry::p_name_index>, describe_field_t<SgAsmJvmMethodParametersEntry,uint16_t,&SgAsmJvmMethodParametersEntry::p_access_flags>>;
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};
41186template <> struct describe_node_t<SgAsmPointerType> {
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<>;
41193 using fields_t = mp::List<describe_field_t<SgAsmPointerType,SgAsmType *,&SgAsmPointerType::p_subtype>>;
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<>;
41216 using fields_t = mp::List<describe_field_t<SgRangeType,SgType*,&SgRangeType::p_base_type>>;
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> {
41222 using parent = SgAsmCilExceptionData;
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> {
41233 using parent = SgAsmCilExceptionData;
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> {
41244 using parent = SgAsmCilExceptionData;
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> {
41255 using parent = SgAsmCilExceptionData;
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> {
41266 using parent = SgAsmCilExceptionData;
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> {
41277 using parent = SgAsmCilExceptionData;
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};
41332template <> struct describe_node_t<SgAsmCilMethodData> {
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<>;
41339 using fields_t = mp::List<describe_field_t<SgAsmCilMethodData,uint64_t,&SgAsmCilMethodData::p_kind>, describe_field_t<SgAsmCilMethodData,std::uint32_t,&SgAsmCilMethodData::p_dataSize>, describe_field_t<SgAsmCilMethodData,std::vector<SgAsmCilExceptionData*>,&SgAsmCilMethodData::p_clauses>>;
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> {
41345 using parent = SgTemplateVariableInstantiation;
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> {
41356 using parent = SgTemplateVariableInstantiation;
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> {
41367 using parent = SgTemplateVariableInstantiation;
41368 using field_type = SgTemplateVariableDeclaration*;
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> {
41378 using parent = SgTemplateVariableInstantiation;
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};
41406 using subclasses_t = mp::List<SgVarRefExp, SgLabelRefExp, SgClassNameRefExp, SgNonrealRefExp, SgScopedRefExp, SgTypeRefExp, SgFunctionRefExp, SgMemberFunctionRefExp, SgTemplateFunctionRefExp, SgTemplateMemberFunctionRefExp>;
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<>;
41430 using fields_t = mp::List<describe_field_t<SgTypeRefExp,SgNamedType * ,&SgTypeRefExp::p_named_type>>;
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<>;
41464 using fields_t = mp::List<describe_field_t<SgScopedRefExp,SgReferenceExp * ,&SgScopedRefExp::p_lhs>, describe_field_t<SgScopedRefExp,SgReferenceExp * ,&SgScopedRefExp::p_rhs>>;
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};
41487 using subclasses_t = mp::List<SgClassSymbol, SgTypedefSymbol, SgEnumSymbol>;
41488 using fields_t = mp::List<>;
41489};
41490template <> struct node_from_variant_t<1067> { using type = SgTypeSymbol; };
41491
41492// Class: AsmJvmSynthetic
41493template <> struct describe_node_t<SgAsmJvmSynthetic> {
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
41505template <> struct describe_node_t<SgAsmJvmDeprecated> {
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};
41539template <> struct describe_node_t<SgSignedCharVal> {
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<>;
41546 using fields_t = mp::List<describe_field_t<SgSignedCharVal,signed char,&SgSignedCharVal::p_value>, describe_field_t<SgSignedCharVal,std::string,&SgSignedCharVal::p_valueString>>;
41547};
41548template <> struct node_from_variant_t<1070> { using type = SgSignedCharVal; };
41549
41550} } }
41551#endif /* Rose_Traits_generated_h */
AstAttributeMechanism
Stores named attributes in Sage IR nodes.
Definition AstAttributeMechanism.h:249
Rose::BinaryAnalysis::RegisterDescriptor
Describes (part of) a physical CPU register.
Definition RegisterDescriptor.h:31
Rose::BinaryAnalysis::RelativeVirtualAddress
Optionally bound relative virtual address.
Definition RelativeVirtualAddress.h:22
SgAccessModifier::access_modifier_enum
access_modifier_enum
Access Modifiers (only one value can be specified)
Definition Cxx_Grammar.h:6754
SgAggregateInitializer::p_initializers
SgExprListExp * p_initializers
This points to a SgExprListExp (list of expressions).
Definition Cxx_Grammar.h:614773
SgAsmAarch32Coprocessor
Operand referencing a Co-processor.
Definition binaryInstruction.C:44519
SgAsmBasicString
String associated with a binary file.
Definition binaryInstruction.C:42423
SgAsmBinaryAdd
Expression that adds two operands.
Definition binaryInstruction.C:42242
SgAsmBinaryAsr
Expression that performs an arithmetic, sign-bit preserving right shift.
Definition binaryInstruction.C:42183
SgAsmBinaryConcat
Expression that concatenates two values to form a wider value.
Definition binaryInstruction.C:42124
SgAsmBinaryDivide
Expression that divides the first operand by the second.
Definition binaryInstruction.C:42065
SgAsmBinaryExpression
Base class for binary expressions.
Definition binaryInstruction.C:42326
SgAsmBinaryLsl
Expression that performs a logical left shift operation.
Definition binaryInstruction.C:42006
SgAsmBinaryLsr
Expression that performs a logical, sign-bit non-preserving right shift.
Definition binaryInstruction.C:41947
SgAsmBinaryMod
Expression that returns the remainder when dividing the first operand by the second.
Definition binaryInstruction.C:41888
SgAsmBinaryMsl
Expression that performs a logical left shift operation filling low-order bits with one.
Definition binaryInstruction.C:41829
SgAsmBinaryMultiply
Expression that multiplies two operands.
Definition binaryInstruction.C:41768
SgAsmBinaryPostupdate
Expression that represents an update to a storage location.
Definition binaryInstruction.C:41709
SgAsmBinaryPreupdate
Expression that represents an update to a storage location.
Definition binaryInstruction.C:41647
SgAsmBinaryRor
Expression that performs a right rotate.
Definition binaryInstruction.C:41585
SgAsmBinarySubtract
Expression that subtracts the second operand from the first.
Definition binaryInstruction.C:41526
SgAsmBlock
Instruction basic block.
Definition binaryInstruction.C:41153
SgAsmByteOrder
Byte order specification.
Definition binaryInstruction.C:41053
SgAsmCilAssemblyOSTable
CIL AssemblyOS tables.
Definition binaryInstruction.C:40447
SgAsmCilAssemblyOS
CIL AssemblyOS node (II.22.3).
Definition binaryInstruction.C:40513
SgAsmCilAssemblyProcessorTable
CIL AssemblyProcessor tables.
Definition binaryInstruction.C:40307
SgAsmCilAssemblyProcessor
CIL AssemblyProcessor node (II.22.4).
Definition binaryInstruction.C:40373
SgAsmCilAssemblyRefOSTable
CIL AssemblyRefOS tables.
Definition binaryInstruction.C:39899
SgAsmCilAssemblyRefOS
CIL AssemblyRefOS node (II.22.6).
Definition binaryInstruction.C:39965
SgAsmCilAssemblyRefProcessorTable
CIL AssemblyRefProcessor tables.
Definition binaryInstruction.C:39740
SgAsmCilAssemblyRefProcessor
CIL AssemblyRefProcessor node (II.22.7).
Definition binaryInstruction.C:39806
SgAsmCilAssemblyRefTable
CIL AssemblyRef tables.
Definition binaryInstruction.C:39674
SgAsmCilAssemblyRef
CIL AssemblyRef node (II.22.5).
Definition binaryInstruction.C:40092
SgAsmCilAssemblyTable
CIL Assembly tables.
Definition binaryInstruction.C:39608
SgAsmCilAssembly
CIL Assembly node (II.22.2).
Definition binaryInstruction.C:40621
SgAsmCilClassLayoutTable
CIL ClassLayout tables.
Definition binaryInstruction.C:39432
SgAsmCilClassLayout
CIL ClassLayout node (II.22.8).
Definition binaryInstruction.C:39498
SgAsmCilConstantTable
CIL Constant tables.
Definition binaryInstruction.C:39238
SgAsmCilConstant
CIL Constant node (II.22.9).
Definition binaryInstruction.C:39304
SgAsmCilCustomAttributeTable
CIL CustomAttribute tables.
Definition binaryInstruction.C:39060
SgAsmCilCustomAttribute
CIL CustomAttribute node (II.22.10).
Definition binaryInstruction.C:39126
SgAsmCilDataStream
Base class for CIL branch of binary analysis IR nodes.
Definition binaryInstruction.C:38913
SgAsmCilDeclSecurityTable
CIL DeclSecurity tables.
Definition binaryInstruction.C:38721
SgAsmCilDeclSecurity
CIL DeclSecurity node (II.22.11).
Definition binaryInstruction.C:38787
SgAsmCilEventMapTable
CIL EventMap tables.
Definition binaryInstruction.C:38450
SgAsmCilEventMap
CIL EventMap node (II.22.12).
Definition binaryInstruction.C:38516
SgAsmCilEvent
CIL Event node (II.22.13).
Definition binaryInstruction.C:38610
SgAsmCilExceptionData
Property class representing CIL Exception clauses (II.25.4.6).
Definition binaryInstruction.C:38241
SgAsmCilExportedTypeTable
CIL ExportedType tables.
Definition binaryInstruction.C:38026
SgAsmCilExportedType
CIL ExportedType node (II.22.14).
Definition binaryInstruction.C:38092
SgAsmCilFieldLayoutTable
CIL FieldLayout tables.
Definition binaryInstruction.C:37756
SgAsmCilFieldLayout
CIL FieldLayout node (II.22.16).
Definition binaryInstruction.C:37822
SgAsmCilFieldMarshalTable
CIL FieldMarshal tables.
Definition binaryInstruction.C:37596
SgAsmCilFieldMarshal
CIL FieldMarshal node (II.22.17).
Definition binaryInstruction.C:37662
SgAsmCilFieldRVATable
CIL FieldRVA tables.
Definition binaryInstruction.C:37437
SgAsmCilFieldRVA
CIL FieldRVA node (II.22.18).
Definition binaryInstruction.C:37503
SgAsmCilField
CIL Field node (II.22.15).
Definition binaryInstruction.C:37915
SgAsmCilFile
CIL File node (II.22.19).
Definition binaryInstruction.C:37260
SgAsmCilGenericParamConstraintTable
CIL GenericParamConstraint tables.
Definition binaryInstruction.C:37034
SgAsmCilGenericParamConstraint
CIL GenericParamConstraint node (II.22.21).
Definition binaryInstruction.C:37100
SgAsmCilGenericParamTable
CIL GenericParam tables.
Definition binaryInstruction.C:36840
SgAsmCilGenericParam
CIL GenericParam node (II.22.20).
Definition binaryInstruction.C:36906
SgAsmCilImplMapTable
CIL ImplMap tables.
Definition binaryInstruction.C:36645
SgAsmCilImplMap
CIL ImplMap node (II.22.22).
Definition binaryInstruction.C:36711
SgAsmCilInterfaceImplTable
CIL InterfaceImpl tables.
Definition binaryInstruction.C:36401
SgAsmCilInterfaceImpl
CIL InterfaceImpl node (II.22.23).
Definition binaryInstruction.C:36467
SgAsmCilManifestResourceTable
CIL ManifestResource tables.
Definition binaryInstruction.C:36207
SgAsmCilManifestResource
CIL ManifestResource node (II.22.24).
Definition binaryInstruction.C:36273
SgAsmCilMemberRefTable
CIL MemberRef tables.
Definition binaryInstruction.C:36029
SgAsmCilMemberRef
CIL MemberRef node (II.22.25).
Definition binaryInstruction.C:36095
SgAsmCilMetadataHeap
CIL SgAsmCilMetadataHeap node.
Definition binaryInstruction.C:35160
SgAsmCilMetadataRoot
CIL SgAsmCilMetadataRoot.
Definition binaryInstruction.C:34866
SgAsmCilMetadata
Base class for CIL branch of binary analysis IR nodes.
Definition binaryInstruction.C:40923
SgAsmCilMethodData
Property class representing CIL Extra Sections (II.25.4.5).
Definition binaryInstruction.C:34748
SgAsmCilMethodDefTable
CIL MethodDef tables.
Definition binaryInstruction.C:34407
SgAsmCilMethodDef
CIL MethodDef node (II.22.26).
Definition binaryInstruction.C:34473
SgAsmCilMethodImplTable
CIL MethodImpl tables.
Definition binaryInstruction.C:34229
SgAsmCilMethodImpl
CIL MethodImpl node (II.22.27).
Definition binaryInstruction.C:34295
SgAsmCilMethodSemanticsTable
CIL MethodSemantics tables.
Definition binaryInstruction.C:34052
SgAsmCilMethodSemantics
CIL MethodSemantics node (II.22.28).
Definition binaryInstruction.C:34118
SgAsmCilMethodSpecTable
CIL MethodSpec tables.
Definition binaryInstruction.C:33892
SgAsmCilMethodSpec
CIL MethodSpec node (II.22.29).
Definition binaryInstruction.C:33958
SgAsmCilModuleRefTable
CIL ModuleRef tables.
Definition binaryInstruction.C:33603
SgAsmCilModuleRef
CIL ModuleRef node (II.22.31).
Definition binaryInstruction.C:33669
SgAsmCilModule
CIL Module node (II.22.30).
Definition binaryInstruction.C:33745
SgAsmCilNestedClassTable
CIL NestedClass tables.
Definition binaryInstruction.C:33377
SgAsmCilNestedClass
CIL NestedClass node (II.22.32).
Definition binaryInstruction.C:33443
SgAsmCilNode
Base class for CIL branch of binary analysis IR nodes.
Definition binaryInstruction.C:40994
SgAsmCilParam
CIL Param node (II.22.33).
Definition binaryInstruction.C:33267
SgAsmCilPropertyMapTable
CIL PropertyMap tables.
Definition binaryInstruction.C:32930
SgAsmCilPropertyMap
CIL PropertyMap node (II.22.35).
Definition binaryInstruction.C:32996
SgAsmCilPropertyTable
CIL Property tables.
Definition binaryInstruction.C:32864
SgAsmCilProperty
CIL Property node (II.22.34).
Definition binaryInstruction.C:33090
SgAsmCilStandAloneSigTable
CIL StandAloneSig tables.
Definition binaryInstruction.C:32722
SgAsmCilStandAloneSig
CIL StandAloneSig node (II.22.36).
Definition binaryInstruction.C:32788
SgAsmCilTypeDefTable
CIL TypeDef tables.
Definition binaryInstruction.C:32490
SgAsmCilTypeDef
CIL TypeDef node (II.22.37).
Definition binaryInstruction.C:32556
SgAsmCilTypeRefTable
CIL TypeRef tables.
Definition binaryInstruction.C:32312
SgAsmCilTypeRef
CIL TypeRef node (II.22.38).
Definition binaryInstruction.C:32378
SgAsmCilTypeSpecTable
CIL TypeSpec tables.
Definition binaryInstruction.C:32170
SgAsmCilTypeSpec
CIL TypeSpec node (II.22.39).
Definition binaryInstruction.C:32236
SgAsmCilUint32Heap
Base class for CIL branch of binary analysis IR nodes.
Definition binaryInstruction.C:32095
SgAsmCilUint8Heap
Base class for CIL branch of binary analysis IR nodes.
Definition binaryInstruction.C:32020
SgAsmCliHeader
CIL Managed Code section.
Definition binaryInstruction.C:30943
SgAsmCoffStrtab
COFF symbol string table.
Definition binaryInstruction.C:30646
SgAsmCoffSymbolList
List of COFF symbols.
Definition binaryInstruction.C:30127
SgAsmConstantExpression
Base class for constants.
Definition binaryInstruction.C:29725
SgAsmDOSFileHeader
Represents the file header for DOS executables.
Definition binaryInstruction.C:28479
SgAsmDirectRegisterExpression
Expression representing a machine register.
Definition binaryInstruction.C:29470
SgAsmElfDynamicEntryList
List of dynamic linking section entries.
Definition binaryInstruction.C:23220
SgAsmElfDynamicEntry
One entry from the dynamic linking table.
Definition binaryInstruction.C:23297
SgAsmElfDynamicSection
ELF section containing dynamic linking information.
Definition binaryInstruction.C:22882
SgAsmElfEHFrameEntryCIList
List of ELF EH frame CI entries.
Definition binaryInstruction.C:22485
SgAsmElfEHFrameEntryCI
ELF error handling frame entry, common information entry.
Definition binaryInstruction.C:22568
SgAsmElfEHFrameEntryFDList
List of ELF error handling frame descriptor entries.
Definition binaryInstruction.C:22264
SgAsmElfEHFrameEntryFD
ELF error handling frame entry frame description entry.
Definition binaryInstruction.C:22341
SgAsmElfEHFrameSection
Represents an ELF EH frame section.
Definition binaryInstruction.C:22153
SgAsmElfFileHeader
Represents the file header of an ELF binary container.
Definition binaryInstruction.C:21673
SgAsmElfNoteEntryList
Node to hold list of ELF note entries.
Definition binaryInstruction.C:21436
SgAsmElfNoteEntry
One entry of an ELF notes table.
Definition binaryInstruction.C:21517
SgAsmElfRelocEntryList
List of ELF relocation entries.
Definition binaryInstruction.C:20962
SgAsmElfRelocEntry
One entry of an ELF relocation table.
Definition binaryInstruction.C:21039
SgAsmElfRelocEntry::RelocType
RelocType
Relocation Type.
Definition binaryInstruction.C:21097
SgAsmElfRelocSection
Represents an ELF relocation section.
Definition binaryInstruction.C:20824
SgAsmElfSectionTableEntry
Represents one entry in an ELF section table.
Definition binaryInstruction.C:20439
SgAsmElfSectionTableEntry::SectionType
SectionType
Section types (host order).
Definition binaryInstruction.C:20539
SgAsmElfSectionTable
Represents an ELF section table.
Definition binaryInstruction.C:20337
SgAsmElfSection
Base class for ELF file sections.
Definition binaryInstruction.C:23015
SgAsmElfSegmentTableEntry
Represents one entry of a segment table.
Definition binaryInstruction.C:19980
SgAsmElfSegmentTableEntry::SegmentType
SegmentType
Segment types (host order).
Definition binaryInstruction.C:20073
SgAsmElfSegmentTable
Represents an ELF segment table.
Definition binaryInstruction.C:19799
SgAsmElfStringSection
ELF string table section.
Definition binaryInstruction.C:19693
SgAsmElfStrtab
ELF string table.
Definition binaryInstruction.C:19576
SgAsmElfSymbolSection
ELF file section containing symbols.
Definition binaryInstruction.C:19091
SgAsmElfSymbol
Represents a single ELF symbol.
Definition binaryInstruction.C:19317
SgAsmElfSymverDefinedAuxList
List of symbol version aux entries.
Definition binaryInstruction.C:18889
SgAsmElfSymverDefinedAux
Auxiliary data for an ELF Symbol Version.
Definition binaryInstruction.C:18968
SgAsmElfSymverDefinedEntryList
List of entries for the ELF symbol version definition table.
Definition binaryInstruction.C:18619
SgAsmElfSymverDefinedEntry
One entry from an ELF symbol version definition table.
Definition binaryInstruction.C:18698
SgAsmElfSymverDefinedSection
The GNU symbol version definitions.
Definition binaryInstruction.C:18446
SgAsmElfSymverEntryList
List of entries from a symbol version table.
Definition binaryInstruction.C:18287
SgAsmElfSymverEntry
Entry in an ELF symbol version table.
Definition binaryInstruction.C:18357
SgAsmElfSymverNeededAuxList
Hods a list of symbol version aux entries.
Definition binaryInstruction.C:18031
SgAsmElfSymverNeededAux
Auxiliary info for needed symbol version.
Definition binaryInstruction.C:18110
SgAsmElfSymverNeededEntryList
List of symbol version needed entries.
Definition binaryInstruction.C:17790
SgAsmElfSymverNeededEntry
One entry of the ELF symbol version needed table.
Definition binaryInstruction.C:17870
SgAsmElfSymverNeededSection
GNU symbol version requirements table.
Definition binaryInstruction.C:17673
SgAsmElfSymverSection
The ELF symbol version table.
Definition binaryInstruction.C:17562
SgAsmExecutableFileFormat
Base class for many binary analysis nodes.
Definition binaryInstruction.C:42663
SgAsmExecutableFileFormat::ExecPurpose
ExecPurpose
General purpose of a binary executable file.
Definition binaryInstruction.C:42955
SgAsmExecutableFileFormat::ExecABI
ExecABI
Application binary interface.
Definition binaryInstruction.C:42748
SgAsmExecutableFileFormat::InsSetArchitecture
InsSetArchitecture
Instruction sets organized by families.
Definition binaryInstruction.C:42773
SgAsmExprListExp
List of expression nodes.
Definition binaryInstruction.C:17477
SgAsmExpression
Base class for expressions.
Definition binaryInstruction.C:44632
SgAsmFloatType
Floating point types.
Definition binaryInstruction.C:17033
SgAsmFunction
Represents a synthesized function.
Definition binaryInstruction.C:16336
SgAsmFunction::function_kind_enum
function_kind_enum
Constants for the "function_kind" property.
Definition binaryInstruction.C:16546
SgAsmFunction::MayReturn
MayReturn
Whether a function returns.
Definition binaryInstruction.C:16449
SgAsmGenericDLLList
List of pointers to other nodes.
Definition binaryInstruction.C:16135
SgAsmGenericDLL
Base class for dynamically linked library information.
Definition binaryInstruction.C:16214
SgAsmGenericFileList
List of AST file node pointers.
Definition binaryInstruction.C:15455
SgAsmGenericFile
Base class for binary files.
Definition binaryInstruction.C:15543
SgAsmGenericFormat
Basic information about an executable container.
Definition binaryInstruction.C:15257
SgAsmGenericHeaderList
List of generic file headers.
Definition binaryInstruction.C:15182
SgAsmGenericHeader
Base class for container file headers.
Definition binaryInstruction.C:28923
SgAsmGenericSectionList
List of pointers to file sections.
Definition binaryInstruction.C:15104
SgAsmGenericSection
Contiguous region of a file.
Definition binaryInstruction.C:31279
SgAsmGenericSection::SectionPurpose
SectionPurpose
Reason for section's existence.
Definition binaryInstruction.C:31438
SgAsmGenericString
Base class for strings related to binary specimens.
Definition binaryInstruction.C:42518
SgAsmGenericStrtab
Base class for string tables.
Definition binaryInstruction.C:30732
SgAsmGenericSymbolList
Node to hold a list of symbol node pointers.
Definition binaryInstruction.C:15026
SgAsmGenericSymbol::SymbolBinding
SymbolBinding
Symbol binding.
Definition binaryInstruction.C:30526
SgAsmGenericSymbol::SymbolDefState
SymbolDefState
Symbol definition state.
Definition binaryInstruction.C:30505
SgAsmIndirectRegisterExpression
Registers accessed indirectly.
Definition binaryInstruction.C:14888
SgAsmInstructionList
List of SgAsmInstruction nodes.
Definition binaryInstruction.C:14800
SgAsmInstruction
Base class for machine instructions.
Definition binaryInstruction.C:43866
SgAsmIntegerValueExpression
Base class for integer values.
Definition binaryInstruction.C:14549
SgAsmInterpretation
Represents an interpretation of a binary container.
Definition binaryInstruction.C:14346
SgAsmJvmAttributeTable
Represents a JVM attribute_info table/array.
Definition binaryInstruction.C:13948
SgAsmJvmAttribute
Base class for a JVM attribute.
Definition binaryInstruction.C:14066
SgAsmJvmBootstrapMethods
The BootstrapMethods attribute is a variable-length attribute in the attributes table of a ClassFile ...
Definition binaryInstruction.C:13743
SgAsmJvmConstantPoolEntry
Represents an entry in a JVM constant pool.
Definition binaryInstruction.C:13013
SgAsmJvmConstantPool
Represents an JVM constant pool.
Definition binaryInstruction.C:12907
SgAsmJvmConstantValue
JVM ConstantValue attribute.
Definition binaryInstruction.C:12819
SgAsmJvmDeprecated
JVM Deprecated attribute.
Definition binaryInstruction.C:12755
SgAsmJvmEnclosingMethod
JVM EnclosingMethod attribute.
Definition binaryInstruction.C:12650
SgAsmJvmExceptionTable
Represents a JVM exception_info table/array.
Definition binaryInstruction.C:12324
SgAsmJvmExceptions
JVM Exceptions attribute.
Definition binaryInstruction.C:12419
SgAsmJvmFieldTable
Represents a JVM field_info table/array.
Definition binaryInstruction.C:12088
SgAsmJvmFileHeader
Represents the file header of an JVM binary container.
Definition binaryInstruction.C:11826
SgAsmJvmInnerClassesEntry
A JVM InnerClasses attribute array entry.
Definition binaryInstruction.C:11681
SgAsmJvmInnerClasses
Represents a JVM InnerClasses attribute.
Definition binaryInstruction.C:11592
SgAsmJvmInstruction
Represents one JVS machine instruction.
Definition binaryInstruction.C:11503
SgAsmJvmLineNumberTable
JVM LineNumberTable attribute.
Definition binaryInstruction.C:11310
SgAsmJvmLocalVariableEntry
JVM LocalVariableEntry.
Definition binaryInstruction.C:11141
SgAsmJvmLocalVariableTable
JVM LocalVariableTable attribute.
Definition binaryInstruction.C:11054
SgAsmJvmLocalVariableTypeEntry
JVM LocalVariableTypeEntry.
Definition binaryInstruction.C:10885
SgAsmJvmLocalVariableTypeTable
JVM LocalVariableTypeTable attribute.
Definition binaryInstruction.C:10798
SgAsmJvmMethodParametersEntry
JVM MethodParametersEntry.
Definition binaryInstruction.C:10525
SgAsmJvmMethodParameters
JVM MethodParameters attribute.
Definition binaryInstruction.C:10437
SgAsmJvmMethodTable
Represents a JVM method_info table/array.
Definition binaryInstruction.C:10342
SgAsmJvmModuleMainClass
JVM ModuleMainClass attribute.
Definition binaryInstruction.C:10254
SgAsmJvmNestHost
JVM NestHost attribute.
Definition binaryInstruction.C:10164
SgAsmJvmNestMembers
JVM NestMembers attribute.
Definition binaryInstruction.C:10074
SgAsmJvmNode
Base class for JVM branch of binary analysis IR nodes.
Definition binaryInstruction.C:14193
SgAsmJvmSignature
JVM Signature attribute.
Definition binaryInstruction.C:9981
SgAsmJvmSourceFile
JVM SourceFile attribute.
Definition binaryInstruction.C:9894
SgAsmJvmStackMapFrame
Represents a frame in a stack map table.
Definition binaryInstruction.C:9700
SgAsmJvmStackMapTable
The StackMapTable attribute is a variable-length attribute in the attributes table of a Code attribut...
Definition binaryInstruction.C:9604
SgAsmJvmStackMapVerificationType
Represents an entry in a stack map table.
Definition binaryInstruction.C:9404
SgAsmJvmSynthetic
JVM Synthetic attribute.
Definition binaryInstruction.C:9341
SgAsmMemoryReferenceExpression
Reference to memory locations.
Definition binaryInstruction.C:7416
SgAsmMipsInstruction
Represents one MIPS machine instruction.
Definition binaryInstruction.C:7336
SgAsmNode
Base class for all binary analysis IR nodes.
Definition binaryInstruction.C:44776
SgAsmOp::asm_operand_constraint_enum
asm_operand_constraint_enum
ASM operand constraints (multiple values can be specified)
Definition Cxx_Grammar.h:636561
SgAsmOp::asm_operand_modifier_enum
asm_operand_modifier_enum
ASM Operand modifiers (multiple values can be specified)
Definition Cxx_Grammar.h:636542
SgAsmOperandList
List of operands for an instruction.
Definition binaryInstruction.C:5427
SgAsmPEExportEntryList
List of pointers to other AST nodes.
Definition binaryInstruction.C:4897
SgAsmPEExportSection
Export file section.
Definition binaryInstruction.C:4663
SgAsmPEFileHeader
Windows PE file header.
Definition binaryInstruction.C:3737
SgAsmPEImportDirectoryList
A list of PE Import Directories.
Definition binaryInstruction.C:3314
SgAsmPEImportDirectory
One import directory per library.
Definition binaryInstruction.C:3402
SgAsmPEImportItemList
A list of imported items.
Definition binaryInstruction.C:2999
SgAsmPEImportItem
A single imported object.
Definition binaryInstruction.C:3085
SgAsmPEImportSection
Portable Executable Import Section.
Definition binaryInstruction.C:2883
SgAsmPERVASizePairList
List of SgAsmPERVASizePair AST nodes.
Definition binaryInstruction.C:2508
SgAsmPESection
Base class for PE sections.
Definition binaryInstruction.C:4802
SgAsmPowerpcInstruction
Represents one PowerPC machine instruction.
Definition binaryInstruction.C:1887
SgAsmRegisterNames
An ordered list of registers.
Definition binaryInstruction.C:1791
SgAsmRegisterReferenceExpression
Base class for references to a machine register.
Definition binaryInstruction.C:29542
SgAsmRiscOperation
Static representation of instruction semantics.
Definition binaryInstruction.C:1621
SgAsmRiscOperation::RiscOperator
RiscOperator
One enum per RISC operator.
Definition binaryInstruction.C:1662
SgAsmScalarType
Base class for scalar types.
Definition binaryInstruction.C:17233
SgAsmStackExpression
Base class for references to a machine register.
Definition binaryInstruction.C:1526
SgAsmStatement
Base class for statement-like subclasses.
Definition binaryInstruction.C:44429
SgAsmStaticData
Represents static data in an executable.
Definition binaryInstruction.C:1439
SgAsmStmt
This class represents the concept of a C Assembler statement.
Definition Cxx_Grammar.h:281596
SgAsmStmt::p_clobberRegisterList
SgAsmStmt::AsmRegisterNameList p_clobberRegisterList
This is the clobber list (list of registers where side-effects happen).
Definition Cxx_Grammar.h:282080
SgAsmStmt::p_operands
SgExpressionPtrList p_operands
List of expressions.
Definition Cxx_Grammar.h:282076
SgAsmStoredString
Strings stored in an ELF or PE container.
Definition binaryInstruction.C:1325
SgAsmStringStorage
Strings stored in an ELF or PE container.
Definition binaryInstruction.C:1209
SgAsmSynthesizedDataStructureDeclaration
Declaration-like nodes that encapsulate multiple instructions.
Definition binaryInstruction.C:1133
SgAsmSynthesizedDeclaration
Base class for synthesized declarations.
Definition binaryInstruction.C:16858
SgAsmType
Base class for binary types.
Definition binaryInstruction.C:17372
SgAsmUnaryExpression
Base class for unary expressions.
Definition binaryInstruction.C:953
SgAsmUnaryMinus
Expression represting negation.
Definition binaryInstruction.C:877
SgAsmUnaryPlus
Expression representing a (no-op) unary plus operation.
Definition binaryInstruction.C:819
SgAsmUnarySignedExtend
Expression representing sign extending.
Definition binaryInstruction.C:699
SgAsmUnaryTruncate
Expression representing truncation.
Definition binaryInstruction.C:637
SgAsmUnaryUnsignedExtend
Expression representing unsigned extending.
Definition binaryInstruction.C:575
SgAsmUserInstruction
Instructions defined at runtime.
Definition binaryInstruction.C:492
SgAsmValueExpression
Base class for values.
Definition binaryInstruction.C:29816
SgAsmVectorType
Base class for vector types.
Definition binaryInstruction.C:395
SgAsmVoidType
A type that doesn't represent any data.
Definition binaryInstruction.C:337
SgAsmX86Instruction
Represents one Intel x86 machine instruction.
Definition binaryInstruction.C:122
SgAssignInitializer
This class represents the rhs of a variable declaration which includes an optional assignment (e....
Definition Cxx_Grammar.h:617794
SgAssignInitializer::p_operand_i
SgExpression * p_operand_i
This points to the internal SgExpression (right-hand-side expression).
Definition Cxx_Grammar.h:618263
SgAssignInitializer::p_expression_type
SgType * p_expression_type
This points to the SgType of the rhs expression.
Definition Cxx_Grammar.h:618267
SgAttributeSpecificationStatement::attribute_spec_enum
attribute_spec_enum
Fortran specific classification of attribute statements (each corresponds to a declaration attribute)...
Definition Cxx_Grammar.h:282719
SgBaseClassModifier::baseclass_modifier_enum
baseclass_modifier_enum
Baseclass Modifiers (only one value can be specified)
Definition Cxx_Grammar.h:13929
SgBasicBlock
This class represents the concept of a block (not a basic block from control flow analysis).
Definition Cxx_Grammar.h:230176
SgBasicBlock::p_statements
SgStatementPtrList p_statements
This pointer an STL list of pointers to SgStatement objects.
Definition Cxx_Grammar.h:230683
SgBinaryOp
This class represents the notion of a binary operator. It is derived from a SgExpression because oper...
Definition Cxx_Grammar.h:496343
SgBinaryOp::p_expression_type
SgType * p_expression_type
This SgType is the type of the operator (function type).
Definition Cxx_Grammar.h:496829
SgBinaryOp::p_rhs_operand_i
SgExpression * p_rhs_operand_i
This is the operand associated with the rhs of the binary operator.
Definition Cxx_Grammar.h:496825
SgBinaryOp::p_lhs_operand_i
SgExpression * p_lhs_operand_i
This is the operand associated with the lhs of the binary operator.
Definition Cxx_Grammar.h:496821
SgBoolValExp
This class represents a boolean value (expression value).
Definition Cxx_Grammar.h:567210
SgBoolValExp::p_value
int p_value
This boolean variable marks the current expression as a left hand side value (lvalue).
Definition Cxx_Grammar.h:567653
SgBreakStmt
This class represents the notion of a break statement (typically used in a switch statment).
Definition Cxx_Grammar.h:388136
SgC_PreprocessorDirectiveStatement
Definition Cxx_Grammar.h:328204
SgCallExpression
This class represents the concept of a generic call expression.
Definition Cxx_Grammar.h:598192
SgCallExpression::p_args
SgExprListExp * p_args
This is a pointer to a SgExprListExp (list of function arguments)
Definition Cxx_Grammar.h:598663
SgCallExpression::p_expression_type
SgType * p_expression_type
This is the type of the return value of the function.
Definition Cxx_Grammar.h:598667
SgCallExpression::p_function
SgExpression * p_function
This pointer points to the expression being assembled with argments for be a function call.
Definition Cxx_Grammar.h:598659
SgCaseOptionStmt
This class represents the concept of a C and C++ case option (used within a switch statement).
Definition Cxx_Grammar.h:384773
SgCaseOptionStmt::p_body
SgStatement * p_body
This pointer points to a SgBasicBlock object.
Definition Cxx_Grammar.h:385256
SgCaseOptionStmt::p_key_range_end
SgExpression * p_key_range_end
This pointer points to the last constant in the range when a gnu range case label is used.
Definition Cxx_Grammar.h:385260
SgCastExp
This class represents a cast of one type to another.
Definition Cxx_Grammar.h:488029
SgCastExp::cast_type_enum
cast_type_enum
Classification of Casts.
Definition Cxx_Grammar.h:488049
SgCatchOptionStmt
This class represents the concept of a catch within a try-catch construct used in C++ exception handl...
Definition Cxx_Grammar.h:242549
SgCatchOptionStmt::p_trystmt
SgTryStmt * p_trystmt
This pointer to a SgTryStmt (a declaration) that is associated with this catch option.
Definition Cxx_Grammar.h:243036
SgCatchOptionStmt::p_body
SgStatement * p_body
This pointer to a SgBasicBlock used to hold the statements to be executed when the exception is caugh...
Definition Cxx_Grammar.h:243032
SgCatchOptionStmt::p_condition
SgVariableDeclaration * p_condition
This pointer to a SgVariableDeclaration.
Definition Cxx_Grammar.h:243028
SgCatchStatementSeq
This class represents the concept of a C++ sequence of catch statements.
Definition Cxx_Grammar.h:396350
SgCatchStatementSeq::p_catch_statement_seq
SgStatementPtrList p_catch_statement_seq
This is an STL list of pointers to SgStatement objects.
Definition Cxx_Grammar.h:396826
SgClassDecl_attr
Definition Cxx_Grammar.h:27936
SgClassDeclaration
This class represents the concept of a class declaration statement. It includes the concept of an ins...
Definition Cxx_Grammar.h:302371
SgClassDeclaration::p_name
SgName p_name
This is the name of the class or instantiated class template.
Definition Cxx_Grammar.h:302958
SgClassDeclaration::p_definition
SgClassDefinition * p_definition
This is the class definition (alway a valid pointer, except for explicitly marked forward declaration...
Definition Cxx_Grammar.h:302970
SgClassDeclaration::p_from_template
bool p_from_template
This records if the class declaration is associated with a template.
Definition Cxx_Grammar.h:302982
SgClassDeclaration::p_type
SgClassType * p_type
This is the type used in the declaration (SgClassType).
Definition Cxx_Grammar.h:302966
SgClassDeclaration::p_class_type
SgClassDeclaration::class_types p_class_type
Enum value classifying this as a class,struct,or union.
Definition Cxx_Grammar.h:302962
SgClassDefinition
This class represents the concept of a class definition in C++.
Definition Cxx_Grammar.h:235929
SgClassDefinition::p_members
SgDeclarationStatementPtrList p_members
This the list of member declarations in the class.
Definition Cxx_Grammar.h:236460
SgClassDefinition::p_inheritances
SgBaseClassPtrList p_inheritances
This the list of base classes specificed in the class definition.
Definition Cxx_Grammar.h:236464
SgClassNameRefExp
This class represents the concept of a C++ expression built from a class name.
Definition Cxx_Grammar.h:649554
SgClassNameRefExp::p_symbol
SgClassSymbol * p_symbol
This pointer points to a SgClassSymbol.
Definition Cxx_Grammar.h:649990
SgClassSymbol
This class represents the concept of a class name within the compiler.
Definition Cxx_Grammar.h:711582
SgClinkageStartStatement
This class represents the concept of a C style extern "C" declaration. But such information (linkage)...
Definition Cxx_Grammar.h:278329
SgConditionalExp
This class represents the concept of a C trinary conditional expression (e.g. "test ?...
Definition Cxx_Grammar.h:607727
SgConditionalExp::p_conditional_exp
SgExpression * p_conditional_exp
This pointer points to a SgExpression object.
Definition Cxx_Grammar.h:608204
SgConditionalExp::p_false_exp
SgExpression * p_false_exp
This pointer points to a SgExpression object.
Definition Cxx_Grammar.h:608212
SgConditionalExp::p_true_exp
SgExpression * p_true_exp
This pointer points to a SgExpression object.
Definition Cxx_Grammar.h:608208
SgConditionalExp::p_expression_type
SgType * p_expression_type
This pointer points to a SgType object.
Definition Cxx_Grammar.h:608216
SgConstVolatileModifier::cv_modifier_enum
cv_modifier_enum
Const Volatile Modifier.
Definition Cxx_Grammar.h:4335
SgConstructorInitializer
This class represents the call of a class constructor to initialize a variable. For example "Foo foo;...
Definition Cxx_Grammar.h:616543
SgConstructorInitializer::p_expression_type
SgType * p_expression_type
This points to the associated type for this constructor.
Definition Cxx_Grammar.h:617067
SgConstructorInitializer::p_need_parenthesis_after_name
bool p_need_parenthesis_after_name
This bool value controls the output of "()" after the class name.
Definition Cxx_Grammar.h:617079
SgConstructorInitializer::p_associated_class_unknown
bool p_associated_class_unknown
This bool value indicates when p_declaration should be a valid pointer.
Definition Cxx_Grammar.h:617083
SgConstructorInitializer::p_need_qualifier
bool p_need_qualifier
This bool value controls the output of the class names qualifier.
Definition Cxx_Grammar.h:617075
SgConstructorInitializer::p_declaration
SgMemberFunctionDeclaration * p_declaration
This points to the associated member function declaration (a constructor).
Definition Cxx_Grammar.h:617059
SgConstructorInitializer::p_args
SgExprListExp * p_args
This points to the argument list of the associated constructor call.
Definition Cxx_Grammar.h:617063
SgConstructorInitializer::p_need_name
bool p_need_name
This bool value controls the output of the class name.
Definition Cxx_Grammar.h:617071
SgContinueStmt
This class represents the concept of a C or C++ continue statement.
Definition Cxx_Grammar.h:389151
SgCtorInitializerList
This class represents the concept of a contructor initializer list (used in constructor (member funct...
Definition Cxx_Grammar.h:299204
SgCtorInitializerList::p_ctors
SgInitializedNamePtrList p_ctors
This is an STL list of pointers to SgInitializedName objects.
Definition Cxx_Grammar.h:299675
SgDataStatementValue::data_statement_value_enum
data_statement_value_enum
Support for Fortran data statement.
Definition Cxx_Grammar.h:81368
SgDeclarationModifier
This class represents modifiers for SgDeclaration (declaration statements).
Definition Cxx_Grammar.h:17978
SgDeclarationModifier::p_storageModifier
SgStorageModifier p_storageModifier
Modified for storage information.
Definition Cxx_Grammar.h:18730
SgDeclarationModifier::p_accessModifier
SgAccessModifier p_accessModifier
Modifier for access information (only set for declarations in class and struct definitions)
Definition Cxx_Grammar.h:18726
SgDeclarationModifier::p_modifierVector
SgBitVector p_modifierVector
Bit vector permitting specification of flags for friend, typedef, export, throw.
Definition Cxx_Grammar.h:18718
SgDeclarationModifier::p_typeModifier
SgTypeModifier p_typeModifier
Modifier for type information.
Definition Cxx_Grammar.h:18722
SgDeclarationModifier::gnu_declaration_visability_enum
gnu_declaration_visability_enum
GNU attribute for visability (only one value can be specified)
Definition Cxx_Grammar.h:18056
SgDeclarationStatement
This class represents the concept of a declaration statement.
Definition Cxx_Grammar.h:269330
SgDeclarationStatement::p_nameOnly
bool p_nameOnly
I think this is somewhat redundant with the purpose of specifying a forward declaration....
Definition Cxx_Grammar.h:269981
SgDeclarationStatement::gnu_extension_visability_attribute_enum
gnu_extension_visability_attribute_enum
GNU extension for visibility modifier (only one value can be specified)
Definition Cxx_Grammar.h:269362
SgDeclarationStatement::p_firstNondefiningDeclaration
SgDeclarationStatement * p_firstNondefiningDeclaration
This pointer is valid if there is a non-defining declaration, and stores the first non-defining decla...
Definition Cxx_Grammar.h:270001
SgDeclarationStatement::p_linkage
std::string p_linkage
This string stores the value "C", "C++", or "fortran" to define the external linkage for generating l...
Definition Cxx_Grammar.h:269973
SgDeclarationStatement::template_specialization_enum
template_specialization_enum
Template Specialization Support.
Definition Cxx_Grammar.h:269347
SgDeclarationStatement::p_declarationModifier
SgDeclarationModifier p_declarationModifier
This is the mechanism to handle declaration modifiers.
Definition Cxx_Grammar.h:269977
SgDeclarationStatement::p_definingDeclaration
SgDeclarationStatement * p_definingDeclaration
This pointer is valid only if a defining declaration exists, and stores the defining declaration wher...
Definition Cxx_Grammar.h:269997
SgDeclarationStatement::p_externBrace
bool p_externBrace
This marks that the declaration appeared with "extern".
Definition Cxx_Grammar.h:269989
SgDeclarationStatement::p_decl_attributes
unsigned int p_decl_attributes
This is old and used to be used to hold modifiers.
Definition Cxx_Grammar.h:269969
SgDeclarationStatement::p_forward
bool p_forward
This marks a declaration as being an explicit forward declaration.
Definition Cxx_Grammar.h:269985
SgDeclarationStatement::p_skipElaborateType
bool p_skipElaborateType
This marks "type elaboration" which is the use of the keyword "class" before variables of type class.
Definition Cxx_Grammar.h:269993
SgDefaultOptionStmt
This class represents the concept of a C or C++ default case within a switch statement.
Definition Cxx_Grammar.h:387043
SgDefaultOptionStmt::p_body
SgStatement * p_body
This pointer points to SgBasicBlock holding the statements executed for the default case of a switch ...
Definition Cxx_Grammar.h:387520
SgDeleteExp
This class represents the concept of a C++ call to the delete operator.
Definition Cxx_Grammar.h:610093
SgDeleteExp::p_need_global_specifier
short p_need_global_specifier
This delete operator needs to be output with "::".
Definition Cxx_Grammar.h:610575
SgDeleteExp::p_variable
SgExpression * p_variable
This pointer points to the variable being deleted.
Definition Cxx_Grammar.h:610567
SgDeleteExp::p_is_array
short p_is_array
This bool value is true only if the delete operator is called on an array (array delete).
Definition Cxx_Grammar.h:610571
SgDirectory
This class represents a directory within a projects file structure of files and directories.
Definition Cxx_Grammar.h:52804
SgDoWhileStmt
This class represents the concept of a do-while statement.
Definition Cxx_Grammar.h:240357
SgDoWhileStmt::p_condition
SgStatement * p_condition
This pointer a SgStatement, the conditional expression in the loop construct.
Definition Cxx_Grammar.h:240831
SgDoWhileStmt::p_body
SgStatement * p_body
This pointer a SgBasicBlock, and holds the statements in the body of the loop.
Definition Cxx_Grammar.h:240827
SgDoubleVal
This class represents the notion of an value (expression value).
Definition Cxx_Grammar.h:582799
SgDoubleVal::p_value
double p_value
This value holds the double represented in the source code.
Definition Cxx_Grammar.h:583246
SgElaboratedTypeModifier::elaborated_type_modifier_enum
elaborated_type_modifier_enum
Elaborated Type Modifiers (only one value can be specified)
Definition Cxx_Grammar.h:11733
SgEnumDeclaration
This class represents the concept of an enum declaration.
Definition Cxx_Grammar.h:280275
SgEnumDeclaration::p_name
SgName p_name
Name of enum type (empty if not named).
Definition Cxx_Grammar.h:280816
SgEnumDeclaration::p_type
SgEnumType * p_type
SgEnumType generated by this enum declaration.
Definition Cxx_Grammar.h:280824
SgEnumDeclaration::p_scope
SgScopeStatement * p_scope
Scope of enum declaration.
Definition Cxx_Grammar.h:280836
SgEnumDeclaration::p_enumerators
SgInitializedNamePtrList p_enumerators
STL list of pointers to SgInitializedName object (used for enum variables).
Definition Cxx_Grammar.h:280832
SgEnumDeclaration::p_embedded
bool p_embedded
Boolean value true if embedded in a typedef declaration (might not be used).
Definition Cxx_Grammar.h:280820
SgExecStatement
This class represents the concept of the dynamic execution of a string, file, or code object....
Definition Cxx_Grammar.h:451926
SgExecStatement::p_globals
SgExpression * p_globals
The global execution environment.
Definition Cxx_Grammar.h:452374
SgExecStatement::p_executable
SgExpression * p_executable
The object to be executed.
Definition Cxx_Grammar.h:452370
SgExecStatement::p_locals
SgExpression * p_locals
The local execution environment.
Definition Cxx_Grammar.h:452378
SgExprListExp
This class represents the concept of a C and C++ expression list.
Definition Cxx_Grammar.h:562155
SgExprStatement
This class represents the concept of a C or C++ statement which contains a expression.
Definition Cxx_Grammar.h:382547
SgExpression
This class represents the notion of an expression. Expressions are derived from SgLocatedNodes,...
Definition Cxx_Grammar.h:476638
SgExpression::p_lvalue
bool p_lvalue
This boolean variable marks the current expression as a left hand side value (lvalue).
Definition Cxx_Grammar.h:477204
SgExpression::p_need_paren
bool p_need_paren
This boolean value marks the current expression as requiring parenthises.
Definition Cxx_Grammar.h:477200
SgFile
This class represents a source file for a project (which may contian many source files and or directo...
Definition Cxx_Grammar.h:30618
SgFile::p_preprocessorDirectivesAndCommentsList
ROSEAttributesListContainerPtr p_preprocessorDirectivesAndCommentsList
This is the container of comments and preprocessor control statements that was extracted from the fil...
Definition Cxx_Grammar.h:32209
SgFile::outputFormatOption_enum
outputFormatOption_enum
Enum type used to specify output of Fortran as fixed for free format.
Definition Cxx_Grammar.h:30646
SgFile::p_no_implicit_inline_templates
bool p_no_implicit_inline_templates
This is a reference to the GNU g++ command line option (same name).
Definition Cxx_Grammar.h:32189
SgFile::p_no_implicit_templates
bool p_no_implicit_templates
This is a reference to the GNU g++ command line option (same name).
Definition Cxx_Grammar.h:32185
SgFile::p_originalCommandLineArgumentList
SgStringList p_originalCommandLineArgumentList
Copy of original argc and argv command line passed to ROSE translator (converted to STL list of strin...
Definition Cxx_Grammar.h:31953
SgFile::languageOption_enum
languageOption_enum
Enum type used to specify output language (option used for testing unparsers).
Definition Cxx_Grammar.h:30660
SgFloatVal
This class represents the notion of an value (expression value).
Definition Cxx_Grammar.h:581776
SgFloatVal::p_value
float p_value
This value holds the float represented in the source code.
Definition Cxx_Grammar.h:582223
SgForAllStatement::forall_statement_kind_enum
forall_statement_kind_enum
This class represents forall statements and the Fortran do concurrent construct.
Definition Cxx_Grammar.h:249090
SgForInitStatement
This class represents the variable declaration or variable initialization withn a for loop.
Definition Cxx_Grammar.h:395267
SgForInitStatement::p_init_stmt
SgStatementPtrList p_init_stmt
This pointer points to list of initializers in a SgForStatement.
Definition Cxx_Grammar.h:395749
SgForStatement
This class represents the concept of a for loop.
Definition Cxx_Grammar.h:232592
SgForStatement::p_for_init_stmt
SgForInitStatement * p_for_init_stmt
This pointer a SgForInitStatement (a list of pointers to statements (SgStatement objects) ).
Definition Cxx_Grammar.h:233117
SgForStatement::p_loop_body
SgStatement * p_loop_body
This pointer a SgBasicBlock, and holds the statements in the body of the loop.
Definition Cxx_Grammar.h:233129
SgForStatement::p_else_body
SgStatement * p_else_body
Holds the statements in the else body of the loop. Currently, only Python supports for loops with els...
Definition Cxx_Grammar.h:233133
SgFuncDecl_attr
Definition Cxx_Grammar.h:26943
SgFunctionCallExp
This class represents the concept of a C++ function call (which is an expression).
Definition Cxx_Grammar.h:599265
SgFunctionDeclaration
This class represents the concept of a function declaration statement.
Definition Cxx_Grammar.h:314488
SgFunctionDeclaration::p_definition
SgFunctionDefinition * p_definition
This variable stores the SgFunctionDefinition.
Definition Cxx_Grammar.h:315232
SgFunctionDeclaration::p_name
SgName p_name
This variable stores the string representing the function name.
Definition Cxx_Grammar.h:315188
SgFunctionDeclaration::p_type
SgFunctionType * p_type
This variable stores the SgFunctionType.
Definition Cxx_Grammar.h:315228
SgFunctionDeclaration::p_decoratorList
SgExprListExp * p_decoratorList
This variable stores a list of decorators.
Definition Cxx_Grammar.h:315216
SgFunctionDeclaration::p_oldStyleDefinition
bool p_oldStyleDefinition
This boolean variable records if the function uses the old style definition.
Definition Cxx_Grammar.h:315236
SgFunctionDeclaration::p_specialFunctionModifier
SgSpecialFunctionModifier p_specialFunctionModifier
This variable stores flags representing use of constructor, destructor, etc.
Definition Cxx_Grammar.h:315200
SgFunctionDeclaration::p_functionModifier
SgFunctionModifier p_functionModifier
This variable stores flags representing use of inline, virtual, etc.
Definition Cxx_Grammar.h:315196
SgFunctionDefinition
This class represents the concept of a scope in C++ (e.g. global scope, fuction scope,...
Definition Cxx_Grammar.h:233811
SgFunctionDefinition::p_body
SgBasicBlock * p_body
This pointer is always valid and points to a SgBasicBlock holding all the statements in the function.
Definition Cxx_Grammar.h:234303
SgFunctionParameterList
This class represents the concept of a declaration list.
Definition Cxx_Grammar.h:271301
SgFunctionParameterList::p_args
SgInitializedNamePtrList p_args
STL list of pointers to SgInitializedName object (used for function parameter declarations).
Definition Cxx_Grammar.h:271781
SgFunctionRefExp
This class represents the function being called and must be assembled in the SgFunctionCall with the ...
Definition Cxx_Grammar.h:653654
SgFunctionTypeSymbol
This class represents the concept of a name and a type. It may be renamed in the future to SgTypeSymb...
Definition Cxx_Grammar.h:707580
SgFunctionTypeTable
This class represents the function type table (stores all function types so that they can be shared i...
Definition Cxx_Grammar.h:268309
SgFunctionTypeTable::p_function_type_table
SgSymbolTable * p_function_type_table
This pointer points to SgSymbolTable used to store function type symbols only.
Definition Cxx_Grammar.h:268760
SgFunctionType
This class represents a type for all functions.
Definition Cxx_Grammar.h:134952
SgGlobal
This class represents the concept of a namespace definition.
Definition Cxx_Grammar.h:229061
SgGlobal::p_declarations
SgDeclarationStatementPtrList p_declarations
This is an STL list of SgDeclarationStatement objects.
Definition Cxx_Grammar.h:229559
SgGotoStatement
This class represents the concept of a C or C++ goto statement.
Definition Cxx_Grammar.h:391189
SgGotoStatement::p_label
SgLabelStatement * p_label
This pointer points to the SgLabelStatement where control flow will be transfered during execution.
Definition Cxx_Grammar.h:391663
SgIOStatement::io_statement_enum
io_statement_enum
Fortran specific classification.
Definition Cxx_Grammar.h:398520
SgIfStmt
This class represents the concept of an "if" construct.
Definition Cxx_Grammar.h:231337
SgIfStmt::p_conditional
SgStatement * p_conditional
This pointer a SgStatement.
Definition Cxx_Grammar.h:231850
SgIfStmt::p_false_body
SgStatement * p_false_body
This pointer a SgBasicBlock, and holds the statements in the "false" body of if statement.
Definition Cxx_Grammar.h:231858
SgIfStmt::p_true_body
SgStatement * p_true_body
This pointer a SgBasicBlock, and holds the statements in the "true" body of if statement.
Definition Cxx_Grammar.h:231854
SgImageControlStatement::image_control_statement_enum
image_control_statement_enum
Fortran specific classification for image control statements.
Definition Cxx_Grammar.h:461103
SgInitializedName
This class represents the notion of a declared variable.
Definition Cxx_Grammar.h:176088
SgInitializedName::p_prev_decl_item
SgInitializedName * p_prev_decl_item
Pointer to the initial uses of this variable previous to its redeclaration declaration.
Definition Cxx_Grammar.h:177105
SgInitializedName::p_storageModifier
SgStorageModifier * p_storageModifier
This is the storage modifier (static, auto, register, mutable, asm, etc.).
Definition Cxx_Grammar.h:177117
SgInitializedName::asm_register_name_enum
asm_register_name_enum
Register names (x86 specific GNU names).
Definition Cxx_Grammar.h:176123
SgInitializedName::p_scope
SgScopeStatement * p_scope
This pointer is always valid and stores the current scope of the variable.
Definition Cxx_Grammar.h:177121
SgInitializedName::p_is_initializer
bool p_is_initializer
flag to determine whether the declaration has an initializer.
Definition Cxx_Grammar.h:177109
SgInitializedName::p_register_name_code
SgInitializedName::asm_register_name_enum p_register_name_code
Code (following GNU standard) for register name.
Definition Cxx_Grammar.h:177133
SgInitializedName::p_initptr
SgInitializer * p_initptr
Pointer to an initializer for the variable.
Definition Cxx_Grammar.h:177101
SgInitializedName::p_preinitialization
SgInitializedName::preinitialization_enum p_preinitialization
This data member stores an enum value.
Definition Cxx_Grammar.h:177125
SgInitializedName::p_typeptr
SgType * p_typeptr
Pointer to a type object that has been associated with SgInitializedName::p_name.
Definition Cxx_Grammar.h:177097
SgInitializedName::p_name
SgName p_name
The variable that is declared in this declaration.
Definition Cxx_Grammar.h:177089
SgInitializedName::p_declptr
SgDeclarationStatement * p_declptr
Pointer to the declaration object where this SgInitializedName object belongs to.
Definition Cxx_Grammar.h:177113
SgInitializedName::preinitialization_enum
preinitialization_enum
Preinitialization Enum (only one value can be specified)
Definition Cxx_Grammar.h:176108
SgInitializer
This class represents the notion of an initializer for a variable declaration or expression in a func...
Definition Cxx_Grammar.h:613244
SgInitializer::p_is_explicit_cast
bool p_is_explicit_cast
This boolean variable marks the initializer ans part of an explicit or implicit cast....
Definition Cxx_Grammar.h:613693
SgIsNotOp
This class represents the physical disequality (often called pointer disequality) operator for langua...
Definition Cxx_Grammar.h:548305
SgIsOp
This class represents the physical equality (often called pointer equality) operator for languages th...
Definition Cxx_Grammar.h:547294
SgJovialForThenStatement::loop_statement_type_enum
loop_statement_type_enum
This class represents the various versions of Jovial loop statements.
Definition Cxx_Grammar.h:258870
SgJovialTableStatement::WordsPerEntry
WordsPerEntry
Enum for words-per-entry in a Jovial table.
Definition Cxx_Grammar.h:309153
SgJovialTableType::StructureSpecifier
StructureSpecifier
Enum for Jovial structure specifiers.
Definition Cxx_Grammar.h:120951
SgLabelStatement
This class represents the concept of a C or C++ label statement.
Definition Cxx_Grammar.h:383590
SgLabelStatement::p_label
SgName p_label
This a SgName object which stores the name of the label.
Definition Cxx_Grammar.h:384102
SgLabelSymbol::label_type_enum
label_type_enum
Type of label used (fortran only)
Definition Cxx_Grammar.h:716604
SgLambdaRefExp
This class represents a lambda expression.
Definition Cxx_Grammar.h:643326
SgLambdaRefExp::p_functionDeclaration
SgFunctionDeclaration * p_functionDeclaration
The implicit function referred to by this lambda.
Definition Cxx_Grammar.h:643777
SgLinkageModifier::linkage_modifier_enum
linkage_modifier_enum
Linkage Modifiers (only one value can be specified)
Definition Cxx_Grammar.h:12839
SgListExp
This class represents a list display.
Definition Cxx_Grammar.h:563226
SgLocatedNode
This class represents the notion of an expression or statement which has a position within the source...
Definition Cxx_Grammar.h:170784
SgLocatedNode::p_attachedPreprocessingInfoPtr
AttachedPreprocessingInfoType * p_attachedPreprocessingInfoPtr
Holds comments and/or preprocessor directives located before or after the current statement of expres...
Definition Cxx_Grammar.h:171496
SgLocatedNode::p_endOfConstruct
Sg_File_Info * p_endOfConstruct
This pointer is always valid and stores the source position of the end of the current construct.
Definition Cxx_Grammar.h:171492
SgLocatedNode::p_startOfConstruct
Sg_File_Info * p_startOfConstruct
This pointer is always valid and stores the source position of the start of the current construct.
Definition Cxx_Grammar.h:171488
SgLongDoubleVal
This class represents the notion of an value (expression value).
Definition Cxx_Grammar.h:583822
SgLongDoubleVal::p_value
long double p_value
This value holds the double represented in the source code.
Definition Cxx_Grammar.h:584269
SgMemberFunctionDeclaration
This class represents the concept of a member function declaration statement.
Definition Cxx_Grammar.h:317438
SgMemberFunctionDeclaration::p_CtorInitializerList
SgCtorInitializerList * p_CtorInitializerList
This is the constructor preinitialization list (used only for the constructor definitions).
Definition Cxx_Grammar.h:317957
SgMemberFunctionRefExp
This class represents the member function being called and must be assembled in the SgFunctionCall wi...
Definition Cxx_Grammar.h:654797
SgMemberFunctionRefExp::p_symbol_i
SgMemberFunctionSymbol * p_symbol_i
This is the SgMemberFunctionSymbol.
Definition Cxx_Grammar.h:655287
SgMemberFunctionRefExp::p_function_type
SgFunctionType * p_function_type
This is a pointer to the SgFunctionType associated with this member function reference.
Definition Cxx_Grammar.h:655295
SgMemberFunctionRefExp::p_need_qualifier
int p_need_qualifier
This boolean value marks if name qualification is required.
Definition Cxx_Grammar.h:655299
SgMemberFunctionRefExp::p_virtual_call
int p_virtual_call
This boolean value marks if the function reference is a virtual function.
Definition Cxx_Grammar.h:655291
SgMinusOp
This class represents the numeric negation of a value. Not to be confused with SgSubtractOp.
Definition Cxx_Grammar.h:480001
SgModifierNodes
This class is not used in ROSE, but is intended to represent a list of SgModifierTypes (similar to th...
Definition Cxx_Grammar.h:3296
SgModifier
This class represents the base class of a number of IR nodes define modifiers within the C++ grammar.
Definition Cxx_Grammar.h:2311
SgName
This class represents strings within the IR nodes.
Definition Cxx_Grammar.h:20726
SgName::p_char
std::string p_char
This pointer points to an internal C style string.
Definition Cxx_Grammar.h:21224
SgNamespaceAliasDeclarationStatement
This class represents the concept of a C++ namespace alias declaration statement.
Definition Cxx_Grammar.h:292450
SgNamespaceAliasDeclarationStatement::p_namespaceDeclaration
SgNamespaceDeclarationStatement * p_namespaceDeclaration
This the namespace to which the alis references.
Definition Cxx_Grammar.h:292930
SgNamespaceAliasDeclarationStatement::p_name
SgName p_name
This the name of the new namespace alias (usually a shorter name).
Definition Cxx_Grammar.h:292926
SgNamespaceDeclarationStatement
This class represents the concept of a C++ namespace declaration.
Definition Cxx_Grammar.h:289205
SgNamespaceDeclarationStatement::p_isUnnamedNamespace
bool p_isUnnamedNamespace
Records special case of an unnamed namespace.
Definition Cxx_Grammar.h:289704
SgNamespaceDeclarationStatement::p_name
SgName p_name
This the name of the new namespace alias (usually a shorter name).
Definition Cxx_Grammar.h:289696
SgNamespaceDeclarationStatement::p_definition
SgNamespaceDefinitionStatement * p_definition
This pointer points to the SgNamespaceDefinitionStatement, which holds the declarations within the na...
Definition Cxx_Grammar.h:289700
SgNamespaceDefinitionStatement
This class represents the concept of a namespace definition.
Definition Cxx_Grammar.h:243646
SgNamespaceDefinitionStatement::p_declarations
SgDeclarationStatementPtrList p_declarations
This is an STL list of SgDeclarationStatement objects.
Definition Cxx_Grammar.h:244162
SgNamespaceDefinitionStatement::p_namespaceDeclaration
SgNamespaceDeclarationStatement * p_namespaceDeclaration
This is a pointer to the SgNamespaceDeclarationStatement.
Definition Cxx_Grammar.h:244166
SgNamespaceSymbol
This class represents the concept of a namespace name within the compiler.
Definition Cxx_Grammar.h:718707
SgNaryBooleanOp
This class represents the notion of an n-ary boolean operation. This node is intended for use with Py...
Definition Cxx_Grammar.h:663391
SgNaryComparisonOp
This class represents the notion of an n-ary comparison operation. This node is intended for use with...
Definition Cxx_Grammar.h:664392
SgNaryOp
This class represents the notion of an n-ary operator. This node is intended for use with Python.
Definition Cxx_Grammar.h:662336
SgNaryOp::p_operands
SgExpressionPtrList p_operands
This is the list of operands associated with this n-ary operator.
Definition Cxx_Grammar.h:662799
SgNaryOp::p_operators
VariantTList p_operators
This is the list of operators associated with this n-ary operator.
Definition Cxx_Grammar.h:662803
SgNewExp
This class represents the concept of a C++ call to the new operator.
Definition Cxx_Grammar.h:608830
SgNewExp::p_placement_args
SgExprListExp * p_placement_args
This is a pointer to the memory allocation placement arguments for the new operator.
Definition Cxx_Grammar.h:609351
SgNewExp::p_need_global_specifier
short p_need_global_specifier
This new operator needs to be output with "::".
Definition Cxx_Grammar.h:609363
SgNewExp::p_builtin_args
SgExpression * p_builtin_args
This is a pointer to the builtin arguments for the new operator (typically the "this" pointer where s...
Definition Cxx_Grammar.h:609359
SgNewExp::p_constructor_args
SgConstructorInitializer * p_constructor_args
This is a pointer to the constructor initializer (which holds its constructor arguments) for the new ...
Definition Cxx_Grammar.h:609355
SgNode
This class represents the base class for all IR nodes within Sage III.
Definition Cxx_Grammar.h:124
SgNode::p_parent
SgNode * p_parent
This is the pointer to the parent IR node in the AST.
Definition Cxx_Grammar.h:1194
SgNode::p_isModified
bool p_isModified
Records if IR node has been modified (data members reset).
Definition Cxx_Grammar.h:1198
SgNode::p_freepointer
SgNode * p_freepointer
This is the pointer to the chain of previously freed objects.
Definition Cxx_Grammar.h:1206
SgOmpClause::omp_default_option_enum
omp_default_option_enum
OpenMP default clause values.
Definition Cxx_Grammar.h:182681
SgOptions
This class represents an object used to initialize the unparsing.
Definition Cxx_Grammar.h:42296
SgPointerAssignOp
This class represents a Fortran pointer assignment. It is not some weird compound assignment operator...
Definition Cxx_Grammar.h:528423
SgPragmaDeclaration
This class represents the concept of a C Assembler statement (untested).
Definition Cxx_Grammar.h:300265
SgProcedureHeaderStatement::subprogram_kind_enum
subprogram_kind_enum
Classification for different types of Fortran subprograms.
Definition Cxx_Grammar.h:323061
SgProject
This class represents a source project, with a list of SgFile objects and global information about th...
Definition Cxx_Grammar.h:39233
SgProject::p_librarySpecifierList
SgStringList p_librarySpecifierList
List of libraries specified using "-lxxx" syntax.
Definition Cxx_Grammar.h:40322
SgProject::p_prelink
bool p_prelink
This controls if we are to handle the prelink (not implemented).
Definition Cxx_Grammar.h:40354
SgProject::p_openmp_linking
bool p_openmp_linking
This flag is used to indicate if OpenMP lowering is requested by the command line so linking to ROSE'...
Definition Cxx_Grammar.h:40462
SgProject::p_includeDirectorySpecifierList
SgStringList p_includeDirectorySpecifierList
List of directories specified with "-I" option on command line.
Definition Cxx_Grammar.h:40330
SgProject::p_objectFileNameList
SgStringList p_objectFileNameList
List of all object files specified on the command line.
Definition Cxx_Grammar.h:40314
SgProject::p_originalCommandLineArgumentList
SgStringList p_originalCommandLineArgumentList
Copy of original argc and argv command line passed to ROSE translator (converted to STL list of strin...
Definition Cxx_Grammar.h:40274
SgProject::p_template_instantiation_mode
SgProject::template_instantiation_enum p_template_instantiation_mode
This controls the degree of template instantiation by ROSE. No template instantiation is required by ...
Definition Cxx_Grammar.h:40358
SgProject::template_instantiation_enum
template_instantiation_enum
Definition Cxx_Grammar.h:39246
SgProject::p_backendErrorCode
int p_backendErrorCode
Error code returnd from processing of generated source code using vendor compiler.
Definition Cxx_Grammar.h:40294
SgProject::p_libraryFileList
SgStringList p_libraryFileList
List of all libraries specified on command line.
Definition Cxx_Grammar.h:40318
SgProject::p_compileOnly
bool p_compileOnly
This controls if we are to act as a linker (by calling the vendor compiler as a linker/prelinker).
Definition Cxx_Grammar.h:40346
SgProject::p_frontendErrorCode
int p_frontendErrorCode
Error code returned from EDG front-end processing.
Definition Cxx_Grammar.h:40278
SgProject::p_sourceFileNameList
SgStringList p_sourceFileNameList
List of all source file names specified on the command line.
Definition Cxx_Grammar.h:40310
SgProject::p_libraryDirectorySpecifierList
SgStringList p_libraryDirectorySpecifierList
List of directories specified with "-L" option on command line.
Definition Cxx_Grammar.h:40326
SgProject::p_outputFileName
std::string p_outputFileName
Filename specific using "-o" option on command line.
Definition Cxx_Grammar.h:40306
SgPythonGlobalStmt
This class represents the concept of a 'global' stmt in Python.
Definition Cxx_Grammar.h:452953
SgPythonGlobalStmt::p_names
SgInitializedNamePtrList p_names
This is a list of SgInitializedNames that are imported into the inner scope.
Definition Cxx_Grammar.h:453413
SgQualifiedNameType
This class represents a OLD concept of the structure require for qualified names when they were in th...
Definition Cxx_Grammar.h:142649
SgQualifiedName
This class represents a OLD concept of the structure require for qualified names when they were in th...
Definition Cxx_Grammar.h:57108
SgRefExp
This class represents the "&" operator (applied to any lvalue).
Definition Cxx_Grammar.h:612253
SgRefExp::p_type_name
SgType * p_type_name
This a SgType, but I forget its significance.
Definition Cxx_Grammar.h:612689
SgReturnStmt
This class represents the concept of a C Assembler statement (untested).
Definition Cxx_Grammar.h:390166
SgScopeOp
This class was part of CC++ support from a long time ago.
Definition Cxx_Grammar.h:523452
SgScopeStatement
This class represents the concept of a scope in C++ (e.g. global scope, fuction scope,...
Definition Cxx_Grammar.h:227380
SgScopeStatement::p_symbol_table
SgSymbolTable * p_symbol_table
This pointer is always valid and stores the symbl table.
Definition Cxx_Grammar.h:228136
SgSizeOfOp
This class represents the "sizeof()" operator (applied to any type).
Definition Cxx_Grammar.h:642107
SgSizeOfOp::p_expression_type
SgType * p_expression_type
This a SgType, the type of the expression.
Definition Cxx_Grammar.h:642615
SgSizeOfOp::p_operand_type
SgType * p_operand_type
This a pointer to the SgType given to the sizeof operator.
Definition Cxx_Grammar.h:642611
SgSizeOfOp::p_operand_expr
SgExpression * p_operand_expr
This a pointer to the expression given to the sizeof operator.
Definition Cxx_Grammar.h:642607
SgSpawnStmt
This class is part of the older CC++ concept. It is not a part of C or C++ (this IR node is not used ...
Definition Cxx_Grammar.h:392276
SgStatementExpression
This class represents the GNU extension "statement expression" (thus is non-standard C and C++).
Definition Cxx_Grammar.h:635499
SgStatementExpression::p_statement
SgStatement * p_statement
This a pointer to the SgStatement (usually a SgBasicBlock).
Definition Cxx_Grammar.h:635953
SgStatement
This class represents the notion of a statement.
Definition Cxx_Grammar.h:225803
SgStmtDeclarationStatement
This class is intended to be a wrapper around SgStatements, allowing them to exist in scopes that onl...
Definition Cxx_Grammar.h:349944
SgStmtDeclarationStatement::p_statement
SgStatement * p_statement
Holds the wrapped statement.
Definition Cxx_Grammar.h:350387
SgStorageModifier
This class represents modifiers specific to storage.
Definition Cxx_Grammar.h:5430
SgStorageModifier::storage_modifier_enum
storage_modifier_enum
Storage Modifiers (only one value can be specified)
Definition Cxx_Grammar.h:5456
SgStringConversion
This class represents the conversion of an arbitrary expression to a string. This node is intended fo...
Definition Cxx_Grammar.h:665393
SgStringConversion::p_expression
SgExpression * p_expression
The expression to be converted to a string.
Definition Cxx_Grammar.h:665836
SgStructureModifier::jovial_structure_modifier_enum
jovial_structure_modifier_enum
Jovial Structure Modifier/Specifier (tight implies serial)
Definition Cxx_Grammar.h:15020
SgSupport
This class represents the base class of a numbr of IR nodes that don't otherwise fit into the existin...
Definition Cxx_Grammar.h:1308
SgSwitchStatement
This class represents the concept of a switch.
Definition Cxx_Grammar.h:241426
SgSwitchStatement::p_body
SgStatement * p_body
This pointer a SgBasicBlock, and holds the cases in the body of the switch.
Definition Cxx_Grammar.h:241917
SgSymbolTable
This class represents the symbol tables used in both SgScopeStatement and the SgFunctionTypeSymbolTab...
Definition Cxx_Grammar.h:21983
SgSymbolTable::p_name
SgName p_name
This is the symbol name (mangled is required).
Definition Cxx_Grammar.h:22691
SgSymbolTable::p_iterator
hash_iterator p_iterator
This iterator is used within some of the deprecated functions.
Definition Cxx_Grammar.h:22687
SgSymbolTable::p_no_name
bool p_no_name
This is a flag to indicate that p_name is empty.
Definition Cxx_Grammar.h:22695
SgSymbolTable::p_table
rose_hash_multimap * p_table
This is lower level symbol table implementation (using an STL hash_multimap)
Definition Cxx_Grammar.h:22699
SgSymbol
This class represents the concept of a name within the compiler.
Definition Cxx_Grammar.h:697308
SgTemplateArgument
This class represents template argument within the use of a template to build an instantiation.
Definition Cxx_Grammar.h:51351
SgTemplateArgument::p_isArrayBoundUnknownType
bool p_isArrayBoundUnknownType
Template arguments can be used as array bounds, if so this this marks the arguments use as such.
Definition Cxx_Grammar.h:51937
SgTemplateArgument::p_type
SgType * p_type
This is the template argument's reference to a type (if it is a type).
Definition Cxx_Grammar.h:51941
SgTemplateArgument::p_explicitlySpecified
bool p_explicitlySpecified
This true only if for a function template the argument is explicit in the source code (it need not al...
Definition Cxx_Grammar.h:51961
SgTemplateArgument::p_expression
SgExpression * p_expression
This is the template argument's reference to an expression (if it is an expression).
Definition Cxx_Grammar.h:51949
SgTemplateDeclaration
This class represents the concept of a template declaration.
Definition Cxx_Grammar.h:284917
SgTemplateDeclaration::p_string
SgName p_string
This is the full template declaration as a string only.
Definition Cxx_Grammar.h:285425
SgTemplateDeclaration::p_name
SgName p_name
This is the name of the template.
Definition Cxx_Grammar.h:285421
SgTemplateDeclaration::p_scope
SgScopeStatement * p_scope
This is the scope of the template declaration.
Definition Cxx_Grammar.h:285437
SgTemplateDeclaration::p_templateParameters
SgTemplateParameterPtrList p_templateParameters
This is the STL list of pointers template parameters (SgTemplateParameter objects)
Definition Cxx_Grammar.h:285433
SgTemplateDeclaration::p_template_kind
SgTemplateDeclaration::template_type_enum p_template_kind
This is the classification of the template declaration.
Definition Cxx_Grammar.h:285429
SgTemplateInstantiationDecl
This class represents the concept of an instantiated class template.
Definition Cxx_Grammar.h:304963
SgTemplateInstantiationDecl::p_templateDeclaration
SgTemplateClassDeclaration * p_templateDeclaration
This is the template declarations (SgTemplateDeclaration) from which this template instantiation is c...
Definition Cxx_Grammar.h:305465
SgTemplateInstantiationDecl::p_templateArguments
SgTemplateArgumentPtrList p_templateArguments
This is a pointer to a list of pointers to SgTemplateArgument objects (used with the SgTemplateDeclar...
Definition Cxx_Grammar.h:305469
SgTemplateInstantiationDecl::p_templateName
SgName p_templateName
This is the name of the templated class (excludes template arguments)
Definition Cxx_Grammar.h:305457
SgTemplateInstantiationDecl::p_templateHeader
SgName p_templateHeader
This data field is not used (or is used internally).
Definition Cxx_Grammar.h:305461
SgTemplateInstantiationDecl::p_nameResetFromMangledForm
bool p_nameResetFromMangledForm
This bool value is set to false at construction and later reset to true within post-processing as eac...
Definition Cxx_Grammar.h:305473
SgTemplateInstantiationDefn
This class represents the concept of a class definition in C++.
Definition Cxx_Grammar.h:237160
SgTemplateInstantiationDirectiveStatement
This class represents the concept of a C++ template instantiation directive.
Definition Cxx_Grammar.h:286094
SgTemplateInstantiationDirectiveStatement::p_declaration
SgDeclarationStatement * p_declaration
This pointer points to associated template instantiation declaration meant to be explicitly instantia...
Definition Cxx_Grammar.h:286554
SgTemplateInstantiationFunctionDecl
This class represents the concept of an instantiation of function template.
Definition Cxx_Grammar.h:320823
SgTemplateInstantiationFunctionDecl::p_templateDeclaration
SgTemplateFunctionDeclaration * p_templateDeclaration
This is the template declarations (SgTemplateDeclaration) from which this template instantiation is c...
Definition Cxx_Grammar.h:321315
SgTemplateInstantiationFunctionDecl::p_nameResetFromMangledForm
bool p_nameResetFromMangledForm
This bool value is set to false at construction and later reset to true within post-processing as eac...
Definition Cxx_Grammar.h:321323
SgTemplateInstantiationFunctionDecl::p_templateArguments
SgTemplateArgumentPtrList p_templateArguments
This is a pointer to a list of pointers to SgTemplateArgument objects (used with the SgTemplateDeclar...
Definition Cxx_Grammar.h:321319
SgTemplateInstantiationFunctionDecl::p_templateName
SgName p_templateName
This is the name of the templated class (in the form "name<args>")
Definition Cxx_Grammar.h:321311
SgTemplateInstantiationMemberFunctionDecl
This class represents the concept of an instantiation of member function template or a member functio...
Definition Cxx_Grammar.h:319686
SgTemplateInstantiationMemberFunctionDecl::p_templateName
SgName p_templateName
This is the name of the templated class (in the form "name<args>")
Definition Cxx_Grammar.h:320175
SgTemplateInstantiationMemberFunctionDecl::p_templateDeclaration
SgTemplateMemberFunctionDeclaration * p_templateDeclaration
This is the template declarations (SgTemplateDeclaration) from which this template instantiation is c...
Definition Cxx_Grammar.h:320179
SgTemplateInstantiationMemberFunctionDecl::p_templateArguments
SgTemplateArgumentPtrList p_templateArguments
This is a pointer to a list of pointers to SgTemplateArgument objects (used with the SgTemplateDeclar...
Definition Cxx_Grammar.h:320183
SgTemplateInstantiationMemberFunctionDecl::p_nameResetFromMangledForm
bool p_nameResetFromMangledForm
This bool value is set to false at construction and later reset to true within post-processing as eac...
Definition Cxx_Grammar.h:320187
SgThisExp
This class represents the "this" operator (can be applied to any member data).
Definition Cxx_Grammar.h:611190
SgThisExp::p_pobj_this
int p_pobj_this
This is not used and is related to a flag from CC++.
Definition Cxx_Grammar.h:611660
SgThisExp::p_class_symbol
SgClassSymbol * p_class_symbol
This is the symbol of the class to which the "this" operator is applied.
Definition Cxx_Grammar.h:611652
SgThrowOp
This class represents the C++ throw expression (handled as a unary operator).
Definition Cxx_Grammar.h:489302
SgThrowOp::e_throw_kind
e_throw_kind
Throw IR node can be used in three different ways.
Definition Cxx_Grammar.h:489314
SgThrowOp::p_throwKind
SgThrowOp::e_throw_kind p_throwKind
This enum value classifies the throw as either of three different kinds.
Definition Cxx_Grammar.h:489768
SgTryStmt
This class represents the concept of try statement within the try-catch support for exception handlin...
Definition Cxx_Grammar.h:385890
SgTryStmt::p_else_body
SgStatement * p_else_body
This pointer points to a SgBasicBlock containing the statements to be executed when control flows off...
Definition Cxx_Grammar.h:386400
SgTryStmt::p_finally_body
SgStatement * p_finally_body
This pointer points to a SgBasicBlock containing the statements to be executed when an unhandled exce...
Definition Cxx_Grammar.h:386404
SgTryStmt::p_catch_statement_seq_root
SgCatchStatementSeq * p_catch_statement_seq_root
This pointer points to a SgCatchStatementSeq and connects the try statement to the sequence of catch ...
Definition Cxx_Grammar.h:386396
SgTryStmt::p_body
SgStatement * p_body
This pointer points to a SgBasicBlock containing the statements to be execued by the try block.
Definition Cxx_Grammar.h:386392
SgTupleExp
This class represents a tuple display.
Definition Cxx_Grammar.h:564213
SgTypeComplex
This class represents a C99 complex type.
Definition Cxx_Grammar.h:143716
SgTypeDefault
This class represents a default type used for some IR nodes (see below).
Definition Cxx_Grammar.h:145762
SgTypeImaginary
This class represents a C99 complex type.
Definition Cxx_Grammar.h:144739
SgTypeModifier::gnu_extension_machine_mode_enum
gnu_extension_machine_mode_enum
GNU Extension Machine Mode type modifiers (only a single value can be specified at one time)
Definition Cxx_Grammar.h:16215
SgTypeString
This class represents a string type used for SgStringVal IR node.
Definition Cxx_Grammar.h:112581
SgType
This class represents the base class for all types.
Definition Cxx_Grammar.h:85423
SgType::p_typedefs
SgTypedefSeq * p_typedefs
This points to IR node which holds a list of typedefs where the base_type if this SgType.
Definition Cxx_Grammar.h:86169
SgType::p_ref_to
SgReferenceType * p_ref_to
This holds the pointer to a SgReferenceType if this type is a reference to another type.
Definition Cxx_Grammar.h:86157
SgType::p_modifiers
SgModifierNodes * p_modifiers
This points to any SgModifierNodes if this type contains type modifiers.
Definition Cxx_Grammar.h:86165
SgType::p_ptr_to
SgPointerType * p_ptr_to
This holds the pointer to a SgPointerType if this type is a pointer to another type.
Definition Cxx_Grammar.h:86161
SgType::p_substitutedForTemplateParam
int p_substitutedForTemplateParam
This boolean variable marks if the current type was originally a template parameter.
Definition Cxx_Grammar.h:86153
SgTypedefDeclaration
This class represents the notion of a typedef declaration.
Definition Cxx_Grammar.h:294590
SgTypedefDeclaration::p_type
SgTypedefType * p_type
This is the resulting type defined by the typedef declaration.
Definition Cxx_Grammar.h:295163
SgTypedefDeclaration::p_base_type
SgType * p_base_type
This is the type being given a new name by the typedef declaration.
Definition Cxx_Grammar.h:295159
SgTypedefDeclaration::p_typedefBaseTypeContainsDefiningDeclaration
bool p_typedefBaseTypeContainsDefiningDeclaration
This flag indicates that the typedef defines a structure.
Definition Cxx_Grammar.h:295175
SgTypedefDeclaration::p_name
SgName p_name
This is the name of the newly defined type.
Definition Cxx_Grammar.h:295155
SgTypedefDeclaration::p_scope
SgScopeStatement * p_scope
This is the scope of the typedef declaration.
Definition Cxx_Grammar.h:295179
SgTypedefDeclaration::p_parent_scope
SgSymbol * p_parent_scope
This is the type symbol of the class when it is a member type (redundent with the the explicitly stor...
Definition Cxx_Grammar.h:295171
SgTypedefDeclaration::p_declaration
SgDeclarationStatement * p_declaration
pointer to the declaration (typically a SgClassDeclaration).
Definition Cxx_Grammar.h:295167
SgTypedefSeq
This class represents a list of associated typedefs for the SgType IR nodes which reference this list...
Definition Cxx_Grammar.h:49161
SgTypedefSeq::p_typedefs
SgTypePtrList p_typedefs
This holds the STL list of pointers to SgTypes.
Definition Cxx_Grammar.h:49606
SgUPC_AccessModifier
Definition Cxx_Grammar.h:9449
SgUPC_AccessModifier::upc_access_modifier_enum
upc_access_modifier_enum
UPC Access Modifiers (only one value can be specified)
Definition Cxx_Grammar.h:9469
SgUnaryOp
This class represents the notion of a unary operator. It is derived from a SgExpression because opera...
Definition Cxx_Grammar.h:477911
SgUnaryOp::p_operand_i
SgExpression * p_operand_i
This is the operand associated with the unary operator.
Definition Cxx_Grammar.h:478400
SgUnaryOp::Sgop_mode
Sgop_mode
Enum value defines operators as prefix or postfix, as appropriate, e.g. operator++().
Definition Cxx_Grammar.h:477953
SgUnaryOp::p_mode
SgUnaryOp::Sgop_mode p_mode
This SgType is the type of the operator (function type).
Definition Cxx_Grammar.h:478408
SgUnaryOp::p_expression_type
SgType * p_expression_type
This SgType is the type of the operator (function type).
Definition Cxx_Grammar.h:478404
SgUnparse_Info
Definition Cxx_Grammar.h:43383
SgUsingDeclarationStatement
This class represents the concept of a C++ using declaration.
Definition Cxx_Grammar.h:311311
SgUsingDeclarationStatement::p_declaration
SgDeclarationStatement * p_declaration
This pointer points to a SgDeclarationStatement whose declaration(s) are available for use in the sco...
Definition Cxx_Grammar.h:311793
SgUsingDeclarationStatement::p_initializedName
SgInitializedName * p_initializedName
This pointer points to a SgDeclarationStatement whose declaration(s) are available for use in the sco...
Definition Cxx_Grammar.h:311797
SgUsingDirectiveStatement
This class represents the concept of a C++ using directive.
Definition Cxx_Grammar.h:301288
SgUsingDirectiveStatement::p_namespaceDeclaration
SgNamespaceDeclarationStatement * p_namespaceDeclaration
This pointer points to namespace declaration being used.
Definition Cxx_Grammar.h:301755
SgValueExp
This class represents the notion of an value (expression value).
Definition Cxx_Grammar.h:566187
SgVarRefExp
This class represents the variable refernece in expressions.
Definition Cxx_Grammar.h:647374
SgVariableDeclaration
This class represents the concept of a C or C++ variable declaration.
Definition Cxx_Grammar.h:272380
SgVariableDeclaration::p_specialization
SgDeclarationStatement::template_specialization_enum p_specialization
This is part of template support (variables of templated types).
Definition Cxx_Grammar.h:273139
SgVariableDeclaration::p_baseTypeDefiningDeclaration
SgDeclarationStatement * p_baseTypeDefiningDeclaration
This is used to traverse type definitions within variable declarations.
Definition Cxx_Grammar.h:273127
SgVariableDeclaration::gnu_extension_declaration_attributes_enum
gnu_extension_declaration_attributes_enum
GNU extension for declaration modifiers (multiple values may be specified)
Definition Cxx_Grammar.h:272398
SgVariableDeclaration::p_variableDeclarationContainsBaseTypeDefiningDeclaration
bool p_variableDeclarationContainsBaseTypeDefiningDeclaration
This bool records if the variable declaration has the explicit defining declaration associated with i...
Definition Cxx_Grammar.h:273135
SgVariableDeclaration::p_variables
SgInitializedNamePtrList p_variables
This is an STL list of pointers to SgInitializedName objects.
Definition Cxx_Grammar.h:273131
SgVariableDefinition
This class represents the definition (initialization) of a variable.
Definition Cxx_Grammar.h:276293
SgVariableDefinition::p_bitfield
SgExpression * p_bitfield
This a pointer to a value specifies the bitwidth of the variable (used to control memory layout/paddi...
Definition Cxx_Grammar.h:276758
SgVariableDefinition::p_vardefn
SgInitializedName * p_vardefn
This pointer points to associated SgInitializedName object (the variable).
Definition Cxx_Grammar.h:276754
SgVariableSymbol
This class represents the concept of a variable name within the compiler (a shared container for the ...
Definition Cxx_Grammar.h:698455
SgWhileStmt
This class represents the concept of a do-while statement.
Definition Cxx_Grammar.h:239202
SgWhileStmt::p_condition
SgStatement * p_condition
This pointer a SgStatement, the conditional expression in the loop construct.
Definition Cxx_Grammar.h:239695
SgWhileStmt::p_body
SgStatement * p_body
This pointer a SgBasicBlock, and holds the statements in the body of the loop.
Definition Cxx_Grammar.h:239699
SgWhileStmt::p_else_body
SgStatement * p_else_body
This pointer to an SgStatement holds the body of the 'else' block.
Definition Cxx_Grammar.h:239703
Sg_File_Info
This class represents the location of the code associated with the IR node in the original source cod...
Definition Cxx_Grammar.h:28931
Sg_File_Info::p_classificationBitField
unsigned int p_classificationBitField
This is mechanism for classification of the IR node.
Definition Cxx_Grammar.h:29669
Sg_File_Info::p_file_id
int p_file_id
This is a key that maps integers to file names, it prevents redundent storage of filename strings.
Definition Cxx_Grammar.h:29657
Sg_File_Info::p_fileIDsToUnparse
SgFileIdList p_fileIDsToUnparse
This set contains a list of all file ids for which the accompanying IR node should be unparsed.
Definition Cxx_Grammar.h:29685
Sg_File_Info::p_col
int p_col
This is the column number of the location of the source code for this IR node.
Definition Cxx_Grammar.h:29665
Sg_File_Info::p_line
int p_line
This is the line number of the location of the source code for this IR node.
Definition Cxx_Grammar.h:29661
rose_graph_integer_edge_hash_map
Definition sageHash.h:270
rose_graph_integer_edge_hash_multimap
Definition sageHash.h:322
rose_graph_integer_node_hash_map
Definition sageHash.h:221
rose_graph_integerpair_edge_hash_multimap
Definition sageHash.h:370
rose_graph_string_integer_hash_multimap
Definition sageHash.h:422
rose_hash_multimap
Hash table support for symbol tables within ROSE.
Definition Cxx_Grammar.h:21910
Rose::BinaryAnalysis::AddressIntervalSet
Sawyer::Container::IntervalSet< AddressInterval > AddressIntervalSet
A set of virtual addresses.
Definition AddressIntervalSet.h:13
Rose::BinaryAnalysis::X86InstructionKind
X86InstructionKind
List of all x86 instructions known to the ROSE disassembler/assembler.
Definition AssemblerX86Init.h:28
Rose::BinaryAnalysis::Address
std::uint64_t Address
Address.
Definition Address.h:11
Rose
The ROSE library.
Definition BinaryTutorial.dox:3
Sawyer
Sawyer support library.
Definition FeasiblePath.h:767
Rose::Traits::generated::describe_field_t
Definition Cxx_Grammar.h:95
Rose::Traits::generated::describe_node_t
Definition Cxx_Grammar.h:94
Rose::metaprog::List
A template list implementing a apply pattern (functor return void but does not have to be pure)
Definition metaprog.h:79
SgAsmNERelocEntry::iname_type
Definition binaryInstruction.C:6240
SgAsmNERelocEntry::iord_type
Definition binaryInstruction.C:6220
SgAsmNERelocEntry::iref_type
Definition binaryInstruction.C:6200
SgAsmNERelocEntry::osfixup_type
Definition binaryInstruction.C:6260
SgFunctionModifier::opencl_work_group_size_t
Definition Cxx_Grammar.h:7916
Generated on Sun May 18 2025 21:54:37 for ROSE by doxygen 1.9.8