ROSE  0.11.98.0
generated.h
1 #ifndef Rose_Traits_generated_h
2 #define Rose_Traits_generated_h
3 namespace Rose {
4 namespace Traits {
5 namespace generated {
6 // Class: AccessModifier
7 template <> struct describe_field_t<SgAccessModifier,SgAccessModifier::access_modifier_enum,&SgAccessModifier::p_modifier> {
8  using parent = SgAccessModifier;
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 };
18 template <> 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<>;
26 };
27 template <> struct node_from_variant_t<1> { using type = SgAccessModifier; };
28 
29 // Class: ActualArgumentExpression
30 template <> struct describe_field_t<SgActualArgumentExpression,SgName,&SgActualArgumentExpression::p_argument_name> {
32  using field_type = SgName;
33  static constexpr size_t position{0};
34  static constexpr char const * const name{"argument_name"};
35  static constexpr char const * const typestr{"SgName"};
36  static constexpr bool traverse{false};
37  static constexpr auto mbr_ptr{&SgActualArgumentExpression::p_argument_name};
38  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
39  using bind = Desc<SgActualArgumentExpression, SgName SgActualArgumentExpression::*, &SgActualArgumentExpression::p_argument_name>;
40 };
41 template <> struct describe_field_t<SgActualArgumentExpression,SgExpression*,&SgActualArgumentExpression::p_expression> {
43  using field_type = SgExpression*;
44  static constexpr size_t position{1};
45  static constexpr char const * const name{"expression"};
46  static constexpr char const * const typestr{"SgExpression*"};
47  static constexpr bool traverse{true};
48  static constexpr auto mbr_ptr{&SgActualArgumentExpression::p_expression};
49  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
50  using bind = Desc<SgActualArgumentExpression, SgExpression* SgActualArgumentExpression::*, &SgActualArgumentExpression::p_expression>;
51 };
54  using base = SgExpression;
55  static constexpr char const * const name{"ActualArgumentExpression"};
56  static constexpr unsigned long variant{2};
57  static constexpr bool concrete{true};
58  using subclasses_t = mp::List<>;
60 };
61 template <> struct node_from_variant_t<2> { using type = SgActualArgumentExpression; };
62 
63 // Class: AbsOp
64 template <> 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 };
73 template <> struct node_from_variant_t<3> { using type = SgAbsOp; };
74 
75 // Class: AdaAccessType
76 template <> 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 };
87 template <> 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 };
98 template <> 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 };
109 template <> struct describe_node_t<SgAdaAccessType> {
110  using node = SgAdaAccessType;
111  using base = SgType;
112  static constexpr char const * const name{"AdaAccessType"};
113  static constexpr unsigned long variant{4};
114  static constexpr bool concrete{true};
115  using subclasses_t = mp::List<>;
117 };
118 template <> struct node_from_variant_t<4> { using type = SgAdaAccessType; };
119 
120 // Class: AdaAcceptStmt
121 template <> struct describe_field_t<SgAdaAcceptStmt,SgFunctionParameterScope*,&SgAdaAcceptStmt::p_parameterScope> {
122  using parent = SgAdaAcceptStmt;
124  static constexpr size_t position{0};
125  static constexpr char const * const name{"parameterScope"};
126  static constexpr char const * const typestr{"SgFunctionParameterScope*"};
127  static constexpr bool traverse{false};
128  static constexpr auto mbr_ptr{&SgAdaAcceptStmt::p_parameterScope};
129  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
130  using bind = Desc<SgAdaAcceptStmt, SgFunctionParameterScope* SgAdaAcceptStmt::*, &SgAdaAcceptStmt::p_parameterScope>;
131 };
132 template <> struct describe_field_t<SgAdaAcceptStmt,SgFunctionParameterList*,&SgAdaAcceptStmt::p_parameterList> {
133  using parent = SgAdaAcceptStmt;
135  static constexpr size_t position{1};
136  static constexpr char const * const name{"parameterList"};
137  static constexpr char const * const typestr{"SgFunctionParameterList*"};
138  static constexpr bool traverse{true};
139  static constexpr auto mbr_ptr{&SgAdaAcceptStmt::p_parameterList};
140  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
141  using bind = Desc<SgAdaAcceptStmt, SgFunctionParameterList* SgAdaAcceptStmt::*, &SgAdaAcceptStmt::p_parameterList>;
142 };
143 template <> 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 };
154 template <> 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 };
165 template <> 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 };
176 template <> struct describe_node_t<SgAdaAcceptStmt> {
177  using node = SgAdaAcceptStmt;
178  using base = SgScopeStatement;
179  static constexpr char const * const name{"AdaAcceptStmt"};
180  static constexpr unsigned long variant{5};
181  static constexpr bool concrete{true};
182  using subclasses_t = mp::List<>;
184 };
185 template <> struct node_from_variant_t<5> { using type = SgAdaAcceptStmt; };
186 
187 // Class: AdaDelayStmt
188 template <> 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 };
199 template <> 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 };
210 template <> struct describe_node_t<SgAdaDelayStmt> {
211  using node = SgAdaDelayStmt;
212  using base = SgStatement;
213  static constexpr char const * const name{"AdaDelayStmt"};
214  static constexpr unsigned long variant{6};
215  static constexpr bool concrete{true};
216  using subclasses_t = mp::List<>;
218 };
219 template <> struct node_from_variant_t<6> { using type = SgAdaDelayStmt; };
220 
221 // Class: AdaEntryDecl
222 template <> 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 };
233 template <> 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 };
244 template <> 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<>;
252 };
253 template <> struct node_from_variant_t<7> { using type = SgAdaEntryDecl; };
254 
255 // Class: AdaExitStmt
256 template <> 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 };
267 template <> 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 };
278 template <> 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 };
289 template <> struct describe_node_t<SgAdaExitStmt> {
290  using node = SgAdaExitStmt;
291  using base = SgStatement;
292  static constexpr char const * const name{"AdaExitStmt"};
293  static constexpr unsigned long variant{8};
294  static constexpr bool concrete{true};
295  using subclasses_t = mp::List<>;
297 };
298 template <> struct node_from_variant_t<8> { using type = SgAdaExitStmt; };
299 
300 // Class: AdaDiscreteType
301 template <> 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 };
310 template <> struct node_from_variant_t<9> { using type = SgAdaDiscreteType; };
311 
312 // Class: AdaFloatVal
313 template <> 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 };
324 template <> struct describe_node_t<SgAdaFloatVal> {
325  using node = SgAdaFloatVal;
326  using base = SgValueExp;
327  static constexpr char const * const name{"AdaFloatVal"};
328  static constexpr unsigned long variant{10};
329  static constexpr bool concrete{true};
330  using subclasses_t = mp::List<>;
332 };
333 template <> struct node_from_variant_t<10> { using type = SgAdaFloatVal; };
334 
335 // Class: AdaLoopStmt
336 template <> 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 };
347 template <> 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 };
358 template <> struct describe_node_t<SgAdaLoopStmt> {
359  using node = SgAdaLoopStmt;
360  using base = SgStatement;
361  static constexpr char const * const name{"AdaLoopStmt"};
362  static constexpr unsigned long variant{11};
363  static constexpr bool concrete{true};
364  using subclasses_t = mp::List<>;
366 };
367 template <> struct node_from_variant_t<11> { using type = SgAdaLoopStmt; };
368 
369 // Class: AdaPackageBody
370 template <> struct describe_field_t<SgAdaPackageBody,SgAdaPackageSpec*,&SgAdaPackageBody::p_spec> {
371  using parent = SgAdaPackageBody;
372  using field_type = SgAdaPackageSpec*;
373  static constexpr size_t position{0};
374  static constexpr char const * const name{"spec"};
375  static constexpr char const * const typestr{"SgAdaPackageSpec*"};
376  static constexpr bool traverse{false};
377  static constexpr auto mbr_ptr{&SgAdaPackageBody::p_spec};
378  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
379  using bind = Desc<SgAdaPackageBody, SgAdaPackageSpec* SgAdaPackageBody::*, &SgAdaPackageBody::p_spec>;
380 };
381 template <> struct describe_field_t<SgAdaPackageBody,SgStatementPtrList,&SgAdaPackageBody::p_statements> {
382  using parent = SgAdaPackageBody;
383  using field_type = SgStatementPtrList;
384  static constexpr size_t position{1};
385  static constexpr char const * const name{"statements"};
386  static constexpr char const * const typestr{"SgStatementPtrList"};
387  static constexpr bool traverse{true};
388  static constexpr auto mbr_ptr{&SgAdaPackageBody::p_statements};
389  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
390  using bind = Desc<SgAdaPackageBody, SgStatementPtrList SgAdaPackageBody::*, &SgAdaPackageBody::p_statements>;
391 };
392 template <> struct describe_node_t<SgAdaPackageBody> {
393  using node = SgAdaPackageBody;
394  using base = SgScopeStatement;
395  static constexpr char const * const name{"AdaPackageBody"};
396  static constexpr unsigned long variant{12};
397  static constexpr bool concrete{true};
398  using subclasses_t = mp::List<>;
400 };
401 template <> struct node_from_variant_t<12> { using type = SgAdaPackageBody; };
402 
403 // Class: AdaPackageBodyDecl
404 template <> struct describe_field_t<SgAdaPackageBodyDecl,SgName,&SgAdaPackageBodyDecl::p_name> {
406  using field_type = SgName;
407  static constexpr size_t position{0};
408  static constexpr char const * const name{"name"};
409  static constexpr char const * const typestr{"SgName"};
410  static constexpr bool traverse{false};
411  static constexpr auto mbr_ptr{&SgAdaPackageBodyDecl::p_name};
412  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
413  using bind = Desc<SgAdaPackageBodyDecl, SgName SgAdaPackageBodyDecl::*, &SgAdaPackageBodyDecl::p_name>;
414 };
415 template <> struct describe_field_t<SgAdaPackageBodyDecl,SgAdaPackageBody*,&SgAdaPackageBodyDecl::p_definition> {
417  using field_type = SgAdaPackageBody*;
418  static constexpr size_t position{1};
419  static constexpr char const * const name{"definition"};
420  static constexpr char const * const typestr{"SgAdaPackageBody*"};
421  static constexpr bool traverse{true};
422  static constexpr auto mbr_ptr{&SgAdaPackageBodyDecl::p_definition};
423  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
424  using bind = Desc<SgAdaPackageBodyDecl, SgAdaPackageBody* SgAdaPackageBodyDecl::*, &SgAdaPackageBodyDecl::p_definition>;
425 };
426 template <> struct describe_field_t<SgAdaPackageBodyDecl,SgScopeStatement*,&SgAdaPackageBodyDecl::p_scope> {
428  using field_type = SgScopeStatement*;
429  static constexpr size_t position{2};
430  static constexpr char const * const name{"scope"};
431  static constexpr char const * const typestr{"SgScopeStatement*"};
432  static constexpr bool traverse{false};
433  static constexpr auto mbr_ptr{&SgAdaPackageBodyDecl::p_scope};
434  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
435  using bind = Desc<SgAdaPackageBodyDecl, SgScopeStatement* SgAdaPackageBodyDecl::*, &SgAdaPackageBodyDecl::p_scope>;
436 };
438  using node = SgAdaPackageBodyDecl;
440  static constexpr char const * const name{"AdaPackageBodyDecl"};
441  static constexpr unsigned long variant{13};
442  static constexpr bool concrete{true};
443  using subclasses_t = mp::List<>;
445 };
446 template <> struct node_from_variant_t<13> { using type = SgAdaPackageBodyDecl; };
447 
448 // Class: AdaPackageSpec
449 template <> struct describe_field_t<SgAdaPackageSpec,SgAdaPackageBody*,&SgAdaPackageSpec::p_body> {
450  using parent = SgAdaPackageSpec;
451  using field_type = SgAdaPackageBody*;
452  static constexpr size_t position{0};
453  static constexpr char const * const name{"body"};
454  static constexpr char const * const typestr{"SgAdaPackageBody*"};
455  static constexpr bool traverse{false};
456  static constexpr auto mbr_ptr{&SgAdaPackageSpec::p_body};
457  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
458  using bind = Desc<SgAdaPackageSpec, SgAdaPackageBody* SgAdaPackageSpec::*, &SgAdaPackageSpec::p_body>;
459 };
460 template <> struct describe_field_t<SgAdaPackageSpec,bool,&SgAdaPackageSpec::p_hasPrivate> {
461  using parent = SgAdaPackageSpec;
462  using field_type = bool;
463  static constexpr size_t position{1};
464  static constexpr char const * const name{"hasPrivate"};
465  static constexpr char const * const typestr{"bool"};
466  static constexpr bool traverse{false};
467  static constexpr auto mbr_ptr{&SgAdaPackageSpec::p_hasPrivate};
468  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
469  using bind = Desc<SgAdaPackageSpec, bool SgAdaPackageSpec::*, &SgAdaPackageSpec::p_hasPrivate>;
470 };
471 template <> struct describe_field_t<SgAdaPackageSpec,SgDeclarationStatementPtrList,&SgAdaPackageSpec::p_declarations> {
472  using parent = SgAdaPackageSpec;
473  using field_type = SgDeclarationStatementPtrList;
474  static constexpr size_t position{2};
475  static constexpr char const * const name{"declarations"};
476  static constexpr char const * const typestr{"SgDeclarationStatementPtrList"};
477  static constexpr bool traverse{true};
478  static constexpr auto mbr_ptr{&SgAdaPackageSpec::p_declarations};
479  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
480  using bind = Desc<SgAdaPackageSpec, SgDeclarationStatementPtrList SgAdaPackageSpec::*, &SgAdaPackageSpec::p_declarations>;
481 };
482 template <> struct describe_node_t<SgAdaPackageSpec> {
483  using node = SgAdaPackageSpec;
484  using base = SgScopeStatement;
485  static constexpr char const * const name{"AdaPackageSpec"};
486  static constexpr unsigned long variant{14};
487  static constexpr bool concrete{true};
488  using subclasses_t = mp::List<>;
490 };
491 template <> struct node_from_variant_t<14> { using type = SgAdaPackageSpec; };
492 
493 // Class: AdaPackageSpecDecl
494 template <> struct describe_field_t<SgAdaPackageSpecDecl,SgName,&SgAdaPackageSpecDecl::p_name> {
496  using field_type = SgName;
497  static constexpr size_t position{0};
498  static constexpr char const * const name{"name"};
499  static constexpr char const * const typestr{"SgName"};
500  static constexpr bool traverse{false};
501  static constexpr auto mbr_ptr{&SgAdaPackageSpecDecl::p_name};
502  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
503  using bind = Desc<SgAdaPackageSpecDecl, SgName SgAdaPackageSpecDecl::*, &SgAdaPackageSpecDecl::p_name>;
504 };
505 template <> struct describe_field_t<SgAdaPackageSpecDecl,SgAdaPackageSpec*,&SgAdaPackageSpecDecl::p_definition> {
507  using field_type = SgAdaPackageSpec*;
508  static constexpr size_t position{1};
509  static constexpr char const * const name{"definition"};
510  static constexpr char const * const typestr{"SgAdaPackageSpec*"};
511  static constexpr bool traverse{true};
512  static constexpr auto mbr_ptr{&SgAdaPackageSpecDecl::p_definition};
513  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
514  using bind = Desc<SgAdaPackageSpecDecl, SgAdaPackageSpec* SgAdaPackageSpecDecl::*, &SgAdaPackageSpecDecl::p_definition>;
515 };
516 template <> struct describe_field_t<SgAdaPackageSpecDecl,SgScopeStatement*,&SgAdaPackageSpecDecl::p_scope> {
518  using field_type = SgScopeStatement*;
519  static constexpr size_t position{2};
520  static constexpr char const * const name{"scope"};
521  static constexpr char const * const typestr{"SgScopeStatement*"};
522  static constexpr bool traverse{false};
523  static constexpr auto mbr_ptr{&SgAdaPackageSpecDecl::p_scope};
524  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
525  using bind = Desc<SgAdaPackageSpecDecl, SgScopeStatement* SgAdaPackageSpecDecl::*, &SgAdaPackageSpecDecl::p_scope>;
526 };
528  using node = SgAdaPackageSpecDecl;
530  static constexpr char const * const name{"AdaPackageSpecDecl"};
531  static constexpr unsigned long variant{15};
532  static constexpr bool concrete{true};
533  using subclasses_t = mp::List<>;
535 };
536 template <> struct node_from_variant_t<15> { using type = SgAdaPackageSpecDecl; };
537 
538 // Class: AdaPackageSymbol
539 template <> struct describe_field_t<SgAdaPackageSymbol,SgDeclarationStatement*,&SgAdaPackageSymbol::p_declaration> {
540  using parent = SgAdaPackageSymbol;
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 };
550 template <> 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<>;
558 };
559 template <> struct node_from_variant_t<16> { using type = SgAdaPackageSymbol; };
560 
561 // Class: AdaRangeConstraint
562 template <> struct describe_field_t<SgAdaRangeConstraint,SgExpression*,&SgAdaRangeConstraint::p_range> {
564  using field_type = SgExpression*;
565  static constexpr size_t position{0};
566  static constexpr char const * const name{"range"};
567  static constexpr char const * const typestr{"SgExpression*"};
568  static constexpr bool traverse{true};
569  static constexpr auto mbr_ptr{&SgAdaRangeConstraint::p_range};
570  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
571  using bind = Desc<SgAdaRangeConstraint, SgExpression* SgAdaRangeConstraint::*, &SgAdaRangeConstraint::p_range>;
572 };
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<>;
581 };
582 template <> struct node_from_variant_t<17> { using type = SgAdaRangeConstraint; };
583 
584 // Class: AdaRenamingDecl
585 template <> 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 };
596 template <> 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 };
607 template <> 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 };
618 template <> struct describe_node_t<SgAdaRenamingDecl> {
619  using node = SgAdaRenamingDecl;
621  static constexpr char const * const name{"AdaRenamingDecl"};
622  static constexpr unsigned long variant{18};
623  static constexpr bool concrete{true};
624  using subclasses_t = mp::List<>;
626 };
627 template <> struct node_from_variant_t<18> { using type = SgAdaRenamingDecl; };
628 
629 // Class: AdaSubtype
630 template <> 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 };
641 template <> struct describe_field_t<SgAdaSubtype,SgAdaTypeConstraint*,&SgAdaSubtype::p_constraint> {
642  using parent = SgAdaSubtype;
644  static constexpr size_t position{1};
645  static constexpr char const * const name{"constraint"};
646  static constexpr char const * const typestr{"SgAdaTypeConstraint*"};
647  static constexpr bool traverse{true};
648  static constexpr auto mbr_ptr{&SgAdaSubtype::p_constraint};
649  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
650  using bind = Desc<SgAdaSubtype, SgAdaTypeConstraint* SgAdaSubtype::*, &SgAdaSubtype::p_constraint>;
651 };
652 template <> 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 };
663 template <> struct describe_node_t<SgAdaSubtype> {
664  using node = SgAdaSubtype;
665  using base = SgType;
666  static constexpr char const * const name{"AdaSubtype"};
667  static constexpr unsigned long variant{19};
668  static constexpr bool concrete{true};
669  using subclasses_t = mp::List<>;
671 };
672 template <> struct node_from_variant_t<19> { using type = SgAdaSubtype; };
673 
674 // Class: AdaTaskBody
675 template <> 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 };
686 template <> 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 };
697 template <> struct describe_node_t<SgAdaTaskBody> {
698  using node = SgAdaTaskBody;
699  using base = SgScopeStatement;
700  static constexpr char const * const name{"AdaTaskBody"};
701  static constexpr unsigned long variant{20};
702  static constexpr bool concrete{true};
703  using subclasses_t = mp::List<>;
705 };
706 template <> struct node_from_variant_t<20> { using type = SgAdaTaskBody; };
707 
708 // Class: AdaTaskBodyDecl
709 template <> 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 };
720 template <> struct describe_field_t<SgAdaTaskBodyDecl,SgAdaTaskBody*,&SgAdaTaskBodyDecl::p_definition> {
721  using parent = SgAdaTaskBodyDecl;
722  using field_type = SgAdaTaskBody*;
723  static constexpr size_t position{1};
724  static constexpr char const * const name{"definition"};
725  static constexpr char const * const typestr{"SgAdaTaskBody*"};
726  static constexpr bool traverse{true};
727  static constexpr auto mbr_ptr{&SgAdaTaskBodyDecl::p_definition};
728  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
729  using bind = Desc<SgAdaTaskBodyDecl, SgAdaTaskBody* SgAdaTaskBodyDecl::*, &SgAdaTaskBodyDecl::p_definition>;
730 };
731 template <> struct describe_node_t<SgAdaTaskBodyDecl> {
732  using node = SgAdaTaskBodyDecl;
734  static constexpr char const * const name{"AdaTaskBodyDecl"};
735  static constexpr unsigned long variant{21};
736  static constexpr bool concrete{true};
737  using subclasses_t = mp::List<>;
739 };
740 template <> struct node_from_variant_t<21> { using type = SgAdaTaskBodyDecl; };
741 
742 // Class: AdaTaskSpec
743 template <> struct describe_field_t<SgAdaTaskSpec,SgAdaTaskBody*,&SgAdaTaskSpec::p_body> {
744  using parent = SgAdaTaskSpec;
745  using field_type = SgAdaTaskBody*;
746  static constexpr size_t position{0};
747  static constexpr char const * const name{"body"};
748  static constexpr char const * const typestr{"SgAdaTaskBody*"};
749  static constexpr bool traverse{false};
750  static constexpr auto mbr_ptr{&SgAdaTaskSpec::p_body};
751  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
752  using bind = Desc<SgAdaTaskSpec, SgAdaTaskBody* SgAdaTaskSpec::*, &SgAdaTaskSpec::p_body>;
753 };
754 template <> struct describe_field_t<SgAdaTaskSpec,bool,&SgAdaTaskSpec::p_hasMembers> {
755  using parent = SgAdaTaskSpec;
756  using field_type = bool;
757  static constexpr size_t position{1};
758  static constexpr char const * const name{"hasMembers"};
759  static constexpr char const * const typestr{"bool"};
760  static constexpr bool traverse{false};
761  static constexpr auto mbr_ptr{&SgAdaTaskSpec::p_hasMembers};
762  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
763  using bind = Desc<SgAdaTaskSpec, bool SgAdaTaskSpec::*, &SgAdaTaskSpec::p_hasMembers>;
764 };
765 template <> struct describe_field_t<SgAdaTaskSpec,SgDeclarationStatementPtrList,&SgAdaTaskSpec::p_declarations> {
766  using parent = SgAdaTaskSpec;
767  using field_type = SgDeclarationStatementPtrList;
768  static constexpr size_t position{2};
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 };
776 template <> struct describe_field_t<SgAdaTaskSpec,bool,&SgAdaTaskSpec::p_hasPrivate> {
777  using parent = SgAdaTaskSpec;
778  using field_type = bool;
779  static constexpr size_t position{3};
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 };
787 template <> struct describe_node_t<SgAdaTaskSpec> {
788  using node = SgAdaTaskSpec;
789  using base = SgScopeStatement;
790  static constexpr char const * const name{"AdaTaskSpec"};
791  static constexpr unsigned long variant{22};
792  static constexpr bool concrete{true};
793  using subclasses_t = mp::List<>;
795 };
796 template <> struct node_from_variant_t<22> { using type = SgAdaTaskSpec; };
797 
798 // Class: AdaTaskSpecDecl
799 template <> 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 };
810 template <> 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 };
821 template <> 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 };
832 template <> struct describe_node_t<SgAdaTaskSpecDecl> {
833  using node = SgAdaTaskSpecDecl;
835  static constexpr char const * const name{"AdaTaskSpecDecl"};
836  static constexpr unsigned long variant{23};
837  static constexpr bool concrete{true};
838  using subclasses_t = mp::List<>;
840 };
841 template <> struct node_from_variant_t<23> { using type = SgAdaTaskSpecDecl; };
842 
843 // Class: AdaTaskSymbol
844 template <> struct describe_field_t<SgAdaTaskSymbol,SgDeclarationStatement*,&SgAdaTaskSymbol::p_declaration> {
845  using parent = SgAdaTaskSymbol;
847  static constexpr size_t position{0};
848  static constexpr char const * const name{"declaration"};
849  static constexpr char const * const typestr{"SgDeclarationStatement*"};
850  static constexpr bool traverse{true};
851  static constexpr auto mbr_ptr{&SgAdaTaskSymbol::p_declaration};
852  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
853  using bind = Desc<SgAdaTaskSymbol, SgDeclarationStatement* SgAdaTaskSymbol::*, &SgAdaTaskSymbol::p_declaration>;
854 };
855 template <> struct describe_node_t<SgAdaTaskSymbol> {
856  using node = SgAdaTaskSymbol;
857  using base = SgSymbol;
858  static constexpr char const * const name{"AdaTaskSymbol"};
859  static constexpr unsigned long variant{24};
860  static constexpr bool concrete{true};
861  using subclasses_t = mp::List<>;
863 };
864 template <> struct node_from_variant_t<24> { using type = SgAdaTaskSymbol; };
865 
866 // Class: AdaTaskRefExp
867 template <> struct describe_field_t<SgAdaTaskRefExp,SgAdaTaskSpecDecl*,&SgAdaTaskRefExp::p_decl> {
868  using parent = SgAdaTaskRefExp;
869  using field_type = SgAdaTaskSpecDecl*;
870  static constexpr size_t position{0};
871  static constexpr char const * const name{"decl"};
872  static constexpr char const * const typestr{"SgAdaTaskSpecDecl*"};
873  static constexpr bool traverse{false};
874  static constexpr auto mbr_ptr{&SgAdaTaskRefExp::p_decl};
875  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
876  using bind = Desc<SgAdaTaskRefExp, SgAdaTaskSpecDecl* SgAdaTaskRefExp::*, &SgAdaTaskRefExp::p_decl>;
877 };
878 template <> struct describe_node_t<SgAdaTaskRefExp> {
879  using node = SgAdaTaskRefExp;
880  using base = SgExpression;
881  static constexpr char const * const name{"AdaTaskRefExp"};
882  static constexpr unsigned long variant{25};
883  static constexpr bool concrete{true};
884  using subclasses_t = mp::List<>;
886 };
887 template <> struct node_from_variant_t<25> { using type = SgAdaTaskRefExp; };
888 
889 // Class: AdaTaskType
890 template <> 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 };
899 template <> struct node_from_variant_t<26> { using type = SgAdaTaskType; };
900 
901 // Class: AdaTaskTypeDecl
902 template <> 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 };
913 template <> 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 };
924 template <> 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 };
935 template <> struct describe_node_t<SgAdaTaskTypeDecl> {
936  using node = SgAdaTaskTypeDecl;
938  static constexpr char const * const name{"AdaTaskTypeDecl"};
939  static constexpr unsigned long variant{27};
940  static constexpr bool concrete{true};
941  using subclasses_t = mp::List<>;
943 };
944 template <> struct node_from_variant_t<27> { using type = SgAdaTaskTypeDecl; };
945 
946 // Class: AdaTypeConstraint
948  using node = SgAdaTypeConstraint;
949  using base = SgLocatedNodeSupport;
950  static constexpr char const * const name{"AdaTypeConstraint"};
951  static constexpr unsigned long variant{28};
952  static constexpr bool concrete{false};
954  using fields_t = mp::List<>;
955 };
956 template <> struct node_from_variant_t<28> { using type = SgAdaTypeConstraint; };
957 
958 // Class: AddOp
959 template <> struct describe_node_t<SgAddOp> {
960  using node = SgAddOp;
961  using base = SgBinaryOp;
962  static constexpr char const * const name{"AddOp"};
963  static constexpr unsigned long variant{29};
964  static constexpr bool concrete{true};
965  using subclasses_t = mp::List<>;
966  using fields_t = mp::List<>;
967 };
968 template <> struct node_from_variant_t<29> { using type = SgAddOp; };
969 
970 // Class: AddressOfOp
971 template <> struct describe_field_t<SgAddressOfOp,SgExpression*,&SgAddressOfOp::p_originalExpressionTree> {
972  using parent = SgAddressOfOp;
973  using field_type = SgExpression*;
974  static constexpr size_t position{0};
975  static constexpr char const * const name{"originalExpressionTree"};
976  static constexpr char const * const typestr{"SgExpression*"};
977  static constexpr bool traverse{false};
978  static constexpr auto mbr_ptr{&SgAddressOfOp::p_originalExpressionTree};
979  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
980  using bind = Desc<SgAddressOfOp, SgExpression* SgAddressOfOp::*, &SgAddressOfOp::p_originalExpressionTree>;
981 };
982 template <> struct describe_node_t<SgAddressOfOp> {
983  using node = SgAddressOfOp;
984  using base = SgUnaryOp;
985  static constexpr char const * const name{"AddressOfOp"};
986  static constexpr unsigned long variant{30};
987  static constexpr bool concrete{true};
988  using subclasses_t = mp::List<>;
990 };
991 template <> struct node_from_variant_t<30> { using type = SgAddressOfOp; };
992 
993 // Class: AggregateInitializer
996  using field_type = SgExprListExp*;
997  static constexpr size_t position{0};
998  static constexpr char const * const name{"initializers"};
999  static constexpr char const * const typestr{"SgExprListExp*"};
1000  static constexpr bool traverse{true};
1001  static constexpr auto mbr_ptr{&SgAggregateInitializer::p_initializers};
1002  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1003  using bind = Desc<SgAggregateInitializer, SgExprListExp* SgAggregateInitializer::*, &SgAggregateInitializer::p_initializers>;
1004 };
1005 template <> struct describe_field_t<SgAggregateInitializer,SgType*,&SgAggregateInitializer::p_expression_type> {
1007  using field_type = SgType*;
1008  static constexpr size_t position{1};
1009  static constexpr char const * const name{"expression_type"};
1010  static constexpr char const * const typestr{"SgType*"};
1011  static constexpr bool traverse{false};
1012  static constexpr auto mbr_ptr{&SgAggregateInitializer::p_expression_type};
1013  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1014  using bind = Desc<SgAggregateInitializer, SgType* SgAggregateInitializer::*, &SgAggregateInitializer::p_expression_type>;
1015 };
1016 template <> struct describe_field_t<SgAggregateInitializer,bool,&SgAggregateInitializer::p_need_explicit_braces> {
1018  using field_type = bool;
1019  static constexpr size_t position{2};
1020  static constexpr char const * const name{"need_explicit_braces"};
1021  static constexpr char const * const typestr{"bool"};
1022  static constexpr bool traverse{false};
1023  static constexpr auto mbr_ptr{&SgAggregateInitializer::p_need_explicit_braces};
1024  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1025  using bind = Desc<SgAggregateInitializer, bool SgAggregateInitializer::*, &SgAggregateInitializer::p_need_explicit_braces>;
1026 };
1027 template <> struct describe_field_t<SgAggregateInitializer,bool,&SgAggregateInitializer::p_uses_compound_literal> {
1029  using field_type = bool;
1030  static constexpr size_t position{3};
1031  static constexpr char const * const name{"uses_compound_literal"};
1032  static constexpr char const * const typestr{"bool"};
1033  static constexpr bool traverse{false};
1034  static constexpr auto mbr_ptr{&SgAggregateInitializer::p_uses_compound_literal};
1035  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1036  using bind = Desc<SgAggregateInitializer, bool SgAggregateInitializer::*, &SgAggregateInitializer::p_uses_compound_literal>;
1037 };
1038 template <> struct describe_field_t<SgAggregateInitializer,bool,&SgAggregateInitializer::p_requiresGlobalNameQualificationOnType> {
1040  using field_type = bool;
1041  static constexpr size_t position{4};
1042  static constexpr char const * const name{"requiresGlobalNameQualificationOnType"};
1043  static constexpr char const * const typestr{"bool"};
1044  static constexpr bool traverse{false};
1045  static constexpr auto mbr_ptr{&SgAggregateInitializer::p_requiresGlobalNameQualificationOnType};
1046  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1047  using bind = Desc<SgAggregateInitializer, bool SgAggregateInitializer::*, &SgAggregateInitializer::p_requiresGlobalNameQualificationOnType>;
1048 };
1049 template <> struct describe_field_t<SgAggregateInitializer,int,&SgAggregateInitializer::p_name_qualification_length_for_type> {
1051  using field_type = int;
1052  static constexpr size_t position{5};
1053  static constexpr char const * const name{"name_qualification_length_for_type"};
1054  static constexpr char const * const typestr{"int"};
1055  static constexpr bool traverse{false};
1056  static constexpr auto mbr_ptr{&SgAggregateInitializer::p_name_qualification_length_for_type};
1057  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1058  using bind = Desc<SgAggregateInitializer, int SgAggregateInitializer::*, &SgAggregateInitializer::p_name_qualification_length_for_type>;
1059 };
1060 template <> struct describe_field_t<SgAggregateInitializer,bool,&SgAggregateInitializer::p_type_elaboration_required_for_type> {
1062  using field_type = bool;
1063  static constexpr size_t position{6};
1064  static constexpr char const * const name{"type_elaboration_required_for_type"};
1065  static constexpr char const * const typestr{"bool"};
1066  static constexpr bool traverse{false};
1067  static constexpr auto mbr_ptr{&SgAggregateInitializer::p_type_elaboration_required_for_type};
1068  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1069  using bind = Desc<SgAggregateInitializer, bool SgAggregateInitializer::*, &SgAggregateInitializer::p_type_elaboration_required_for_type>;
1070 };
1071 template <> struct describe_field_t<SgAggregateInitializer,bool,&SgAggregateInitializer::p_global_qualification_required_for_type> {
1073  using field_type = bool;
1074  static constexpr size_t position{7};
1075  static constexpr char const * const name{"global_qualification_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_global_qualification_required_for_type};
1079  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1080  using bind = Desc<SgAggregateInitializer, bool SgAggregateInitializer::*, &SgAggregateInitializer::p_global_qualification_required_for_type>;
1081 };
1082 template <> struct describe_field_t<SgAggregateInitializer,SgExpression*,&SgAggregateInitializer::p_originalExpressionTree> {
1084  using field_type = SgExpression*;
1085  static constexpr size_t position{8};
1086  static constexpr char const * const name{"originalExpressionTree"};
1087  static constexpr char const * const typestr{"SgExpression*"};
1088  static constexpr bool traverse{false};
1089  static constexpr auto mbr_ptr{&SgAggregateInitializer::p_originalExpressionTree};
1090  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1091  using bind = Desc<SgAggregateInitializer, SgExpression* SgAggregateInitializer::*, &SgAggregateInitializer::p_originalExpressionTree>;
1092 };
1094  using node = SgAggregateInitializer;
1095  using base = SgInitializer;
1096  static constexpr char const * const name{"AggregateInitializer"};
1097  static constexpr unsigned long variant{31};
1098  static constexpr bool concrete{true};
1099  using subclasses_t = mp::List<>;
1101 };
1102 template <> struct node_from_variant_t<31> { using type = SgAggregateInitializer; };
1103 
1104 // Class: AliasSymbol
1105 template <> struct describe_field_t<SgAliasSymbol,SgSymbol*,&SgAliasSymbol::p_alias> {
1106  using parent = SgAliasSymbol;
1107  using field_type = SgSymbol*;
1108  static constexpr size_t position{0};
1109  static constexpr char const * const name{"alias"};
1110  static constexpr char const * const typestr{"SgSymbol*"};
1111  static constexpr bool traverse{true};
1112  static constexpr auto mbr_ptr{&SgAliasSymbol::p_alias};
1113  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1114  using bind = Desc<SgAliasSymbol, SgSymbol* SgAliasSymbol::*, &SgAliasSymbol::p_alias>;
1115 };
1116 template <> struct describe_field_t<SgAliasSymbol,bool,&SgAliasSymbol::p_isRenamed> {
1117  using parent = SgAliasSymbol;
1118  using field_type = bool;
1119  static constexpr size_t position{1};
1120  static constexpr char const * const name{"isRenamed"};
1121  static constexpr char const * const typestr{"bool"};
1122  static constexpr bool traverse{false};
1123  static constexpr auto mbr_ptr{&SgAliasSymbol::p_isRenamed};
1124  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1125  using bind = Desc<SgAliasSymbol, bool SgAliasSymbol::*, &SgAliasSymbol::p_isRenamed>;
1126 };
1127 template <> struct describe_field_t<SgAliasSymbol,SgName,&SgAliasSymbol::p_new_name> {
1128  using parent = SgAliasSymbol;
1129  using field_type = SgName;
1130  static constexpr size_t position{2};
1131  static constexpr char const * const name{"new_name"};
1132  static constexpr char const * const typestr{"SgName"};
1133  static constexpr bool traverse{false};
1134  static constexpr auto mbr_ptr{&SgAliasSymbol::p_new_name};
1135  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1136  using bind = Desc<SgAliasSymbol, SgName SgAliasSymbol::*, &SgAliasSymbol::p_new_name>;
1137 };
1138 template <> struct describe_field_t<SgAliasSymbol,SgNodePtrList,&SgAliasSymbol::p_causal_nodes> {
1139  using parent = SgAliasSymbol;
1140  using field_type = SgNodePtrList;
1141  static constexpr size_t position{3};
1142  static constexpr char const * const name{"causal_nodes"};
1143  static constexpr char const * const typestr{"SgNodePtrList"};
1144  static constexpr bool traverse{false};
1145  static constexpr auto mbr_ptr{&SgAliasSymbol::p_causal_nodes};
1146  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1147  using bind = Desc<SgAliasSymbol, SgNodePtrList SgAliasSymbol::*, &SgAliasSymbol::p_causal_nodes>;
1148 };
1149 template <> struct describe_node_t<SgAliasSymbol> {
1150  using node = SgAliasSymbol;
1151  using base = SgSymbol;
1152  static constexpr char const * const name{"AliasSymbol"};
1153  static constexpr unsigned long variant{32};
1154  static constexpr bool concrete{true};
1155  using subclasses_t = mp::List<>;
1157 };
1158 template <> struct node_from_variant_t<32> { using type = SgAliasSymbol; };
1159 
1160 // Class: AllocateStatement
1161 template <> struct describe_field_t<SgAllocateStatement,SgExprListExp*,&SgAllocateStatement::p_expr_list> {
1162  using parent = SgAllocateStatement;
1163  using field_type = SgExprListExp*;
1164  static constexpr size_t position{0};
1165  static constexpr char const * const name{"expr_list"};
1166  static constexpr char const * const typestr{"SgExprListExp*"};
1167  static constexpr bool traverse{true};
1168  static constexpr auto mbr_ptr{&SgAllocateStatement::p_expr_list};
1169  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1170  using bind = Desc<SgAllocateStatement, SgExprListExp* SgAllocateStatement::*, &SgAllocateStatement::p_expr_list>;
1171 };
1172 template <> struct describe_field_t<SgAllocateStatement,SgExpression*,&SgAllocateStatement::p_stat_expression> {
1173  using parent = SgAllocateStatement;
1174  using field_type = SgExpression*;
1175  static constexpr size_t position{1};
1176  static constexpr char const * const name{"stat_expression"};
1177  static constexpr char const * const typestr{"SgExpression*"};
1178  static constexpr bool traverse{true};
1179  static constexpr auto mbr_ptr{&SgAllocateStatement::p_stat_expression};
1180  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1181  using bind = Desc<SgAllocateStatement, SgExpression* SgAllocateStatement::*, &SgAllocateStatement::p_stat_expression>;
1182 };
1183 template <> struct describe_field_t<SgAllocateStatement,SgExpression*,&SgAllocateStatement::p_errmsg_expression> {
1184  using parent = SgAllocateStatement;
1185  using field_type = SgExpression*;
1186  static constexpr size_t position{2};
1187  static constexpr char const * const name{"errmsg_expression"};
1188  static constexpr char const * const typestr{"SgExpression*"};
1189  static constexpr bool traverse{true};
1190  static constexpr auto mbr_ptr{&SgAllocateStatement::p_errmsg_expression};
1191  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1192  using bind = Desc<SgAllocateStatement, SgExpression* SgAllocateStatement::*, &SgAllocateStatement::p_errmsg_expression>;
1193 };
1194 template <> struct describe_field_t<SgAllocateStatement,SgExpression*,&SgAllocateStatement::p_source_expression> {
1195  using parent = SgAllocateStatement;
1196  using field_type = SgExpression*;
1197  static constexpr size_t position{3};
1198  static constexpr char const * const name{"source_expression"};
1199  static constexpr char const * const typestr{"SgExpression*"};
1200  static constexpr bool traverse{true};
1201  static constexpr auto mbr_ptr{&SgAllocateStatement::p_source_expression};
1202  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1203  using bind = Desc<SgAllocateStatement, SgExpression* SgAllocateStatement::*, &SgAllocateStatement::p_source_expression>;
1204 };
1206  using node = SgAllocateStatement;
1207  using base = SgStatement;
1208  static constexpr char const * const name{"AllocateStatement"};
1209  static constexpr unsigned long variant{33};
1210  static constexpr bool concrete{true};
1211  using subclasses_t = mp::List<>;
1213 };
1214 template <> struct node_from_variant_t<33> { using type = SgAllocateStatement; };
1215 
1216 // Class: AndAssignOp
1217 template <> struct describe_node_t<SgAndAssignOp> {
1218  using node = SgAndAssignOp;
1219  using base = SgCompoundAssignOp;
1220  static constexpr char const * const name{"AndAssignOp"};
1221  static constexpr unsigned long variant{34};
1222  static constexpr bool concrete{true};
1223  using subclasses_t = mp::List<>;
1224  using fields_t = mp::List<>;
1225 };
1226 template <> struct node_from_variant_t<34> { using type = SgAndAssignOp; };
1227 
1228 // Class: AndOp
1229 template <> struct describe_node_t<SgAndOp> {
1230  using node = SgAndOp;
1231  using base = SgBinaryOp;
1232  static constexpr char const * const name{"AndOp"};
1233  static constexpr unsigned long variant{35};
1234  static constexpr bool concrete{true};
1235  using subclasses_t = mp::List<>;
1236  using fields_t = mp::List<>;
1237 };
1238 template <> struct node_from_variant_t<35> { using type = SgAndOp; };
1239 
1240 // Class: ArithmeticIfStatement
1241 template <> struct describe_field_t<SgArithmeticIfStatement,SgExpression*,&SgArithmeticIfStatement::p_conditional> {
1243  using field_type = SgExpression*;
1244  static constexpr size_t position{0};
1245  static constexpr char const * const name{"conditional"};
1246  static constexpr char const * const typestr{"SgExpression*"};
1247  static constexpr bool traverse{true};
1248  static constexpr auto mbr_ptr{&SgArithmeticIfStatement::p_conditional};
1249  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1250  using bind = Desc<SgArithmeticIfStatement, SgExpression* SgArithmeticIfStatement::*, &SgArithmeticIfStatement::p_conditional>;
1251 };
1252 template <> struct describe_field_t<SgArithmeticIfStatement,SgLabelRefExp*,&SgArithmeticIfStatement::p_less_label> {
1254  using field_type = SgLabelRefExp*;
1255  static constexpr size_t position{1};
1256  static constexpr char const * const name{"less_label"};
1257  static constexpr char const * const typestr{"SgLabelRefExp*"};
1258  static constexpr bool traverse{false};
1259  static constexpr auto mbr_ptr{&SgArithmeticIfStatement::p_less_label};
1260  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1261  using bind = Desc<SgArithmeticIfStatement, SgLabelRefExp* SgArithmeticIfStatement::*, &SgArithmeticIfStatement::p_less_label>;
1262 };
1263 template <> struct describe_field_t<SgArithmeticIfStatement,SgLabelRefExp*,&SgArithmeticIfStatement::p_equal_label> {
1265  using field_type = SgLabelRefExp*;
1266  static constexpr size_t position{2};
1267  static constexpr char const * const name{"equal_label"};
1268  static constexpr char const * const typestr{"SgLabelRefExp*"};
1269  static constexpr bool traverse{false};
1270  static constexpr auto mbr_ptr{&SgArithmeticIfStatement::p_equal_label};
1271  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1272  using bind = Desc<SgArithmeticIfStatement, SgLabelRefExp* SgArithmeticIfStatement::*, &SgArithmeticIfStatement::p_equal_label>;
1273 };
1274 template <> struct describe_field_t<SgArithmeticIfStatement,SgLabelRefExp*,&SgArithmeticIfStatement::p_greater_label> {
1276  using field_type = SgLabelRefExp*;
1277  static constexpr size_t position{3};
1278  static constexpr char const * const name{"greater_label"};
1279  static constexpr char const * const typestr{"SgLabelRefExp*"};
1280  static constexpr bool traverse{false};
1281  static constexpr auto mbr_ptr{&SgArithmeticIfStatement::p_greater_label};
1282  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1283  using bind = Desc<SgArithmeticIfStatement, SgLabelRefExp* SgArithmeticIfStatement::*, &SgArithmeticIfStatement::p_greater_label>;
1284 };
1286  using node = SgArithmeticIfStatement;
1287  using base = SgStatement;
1288  static constexpr char const * const name{"ArithmeticIfStatement"};
1289  static constexpr unsigned long variant{36};
1290  static constexpr bool concrete{true};
1291  using subclasses_t = mp::List<>;
1293 };
1294 template <> struct node_from_variant_t<36> { using type = SgArithmeticIfStatement; };
1295 
1296 // Class: ArrayType
1297 template <> struct describe_field_t<SgArrayType,SgType*,&SgArrayType::p_base_type> {
1298  using parent = SgArrayType;
1299  using field_type = SgType*;
1300  static constexpr size_t position{0};
1301  static constexpr char const * const name{"base_type"};
1302  static constexpr char const * const typestr{"SgType*"};
1303  static constexpr bool traverse{false};
1304  static constexpr auto mbr_ptr{&SgArrayType::p_base_type};
1305  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1306  using bind = Desc<SgArrayType, SgType* SgArrayType::*, &SgArrayType::p_base_type>;
1307 };
1308 template <> struct describe_field_t<SgArrayType,SgExpression*,&SgArrayType::p_index> {
1309  using parent = SgArrayType;
1310  using field_type = SgExpression*;
1311  static constexpr size_t position{1};
1312  static constexpr char const * const name{"index"};
1313  static constexpr char const * const typestr{"SgExpression*"};
1314  static constexpr bool traverse{true};
1315  static constexpr auto mbr_ptr{&SgArrayType::p_index};
1316  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1317  using bind = Desc<SgArrayType, SgExpression* SgArrayType::*, &SgArrayType::p_index>;
1318 };
1319 template <> struct describe_field_t<SgArrayType,SgExprListExp*,&SgArrayType::p_dim_info> {
1320  using parent = SgArrayType;
1321  using field_type = SgExprListExp*;
1322  static constexpr size_t position{2};
1323  static constexpr char const * const name{"dim_info"};
1324  static constexpr char const * const typestr{"SgExprListExp*"};
1325  static constexpr bool traverse{true};
1326  static constexpr auto mbr_ptr{&SgArrayType::p_dim_info};
1327  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1328  using bind = Desc<SgArrayType, SgExprListExp* SgArrayType::*, &SgArrayType::p_dim_info>;
1329 };
1330 template <> struct describe_field_t<SgArrayType,int,&SgArrayType::p_rank> {
1331  using parent = SgArrayType;
1332  using field_type = int;
1333  static constexpr size_t position{3};
1334  static constexpr char const * const name{"rank"};
1335  static constexpr char const * const typestr{"int"};
1336  static constexpr bool traverse{false};
1337  static constexpr auto mbr_ptr{&SgArrayType::p_rank};
1338  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1339  using bind = Desc<SgArrayType, int SgArrayType::*, &SgArrayType::p_rank>;
1340 };
1341 template <> struct describe_field_t<SgArrayType,int,&SgArrayType::p_number_of_elements> {
1342  using parent = SgArrayType;
1343  using field_type = int;
1344  static constexpr size_t position{4};
1345  static constexpr char const * const name{"number_of_elements"};
1346  static constexpr char const * const typestr{"int"};
1347  static constexpr bool traverse{false};
1348  static constexpr auto mbr_ptr{&SgArrayType::p_number_of_elements};
1349  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1350  using bind = Desc<SgArrayType, int SgArrayType::*, &SgArrayType::p_number_of_elements>;
1351 };
1352 template <> struct describe_field_t<SgArrayType,bool,&SgArrayType::p_is_variable_length_array> {
1353  using parent = SgArrayType;
1354  using field_type = bool;
1355  static constexpr size_t position{5};
1356  static constexpr char const * const name{"is_variable_length_array"};
1357  static constexpr char const * const typestr{"bool"};
1358  static constexpr bool traverse{false};
1359  static constexpr auto mbr_ptr{&SgArrayType::p_is_variable_length_array};
1360  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1361  using bind = Desc<SgArrayType, bool SgArrayType::*, &SgArrayType::p_is_variable_length_array>;
1362 };
1363 template <> struct describe_node_t<SgArrayType> {
1364  using node = SgArrayType;
1365  using base = SgType;
1366  static constexpr char const * const name{"ArrayType"};
1367  static constexpr unsigned long variant{37};
1368  static constexpr bool concrete{true};
1369  using subclasses_t = mp::List<>;
1371 };
1372 template <> struct node_from_variant_t<37> { using type = SgArrayType; };
1373 
1374 // Class: ArrowExp
1375 template <> struct describe_node_t<SgArrowExp> {
1376  using node = SgArrowExp;
1377  using base = SgBinaryOp;
1378  static constexpr char const * const name{"ArrowExp"};
1379  static constexpr unsigned long variant{38};
1380  static constexpr bool concrete{true};
1381  using subclasses_t = mp::List<>;
1382  using fields_t = mp::List<>;
1383 };
1384 template <> struct node_from_variant_t<38> { using type = SgArrowExp; };
1385 
1386 // Class: ArrowStarOp
1387 template <> struct describe_node_t<SgArrowStarOp> {
1388  using node = SgArrowStarOp;
1389  using base = SgBinaryOp;
1390  static constexpr char const * const name{"ArrowStarOp"};
1391  static constexpr unsigned long variant{39};
1392  static constexpr bool concrete{true};
1393  using subclasses_t = mp::List<>;
1394  using fields_t = mp::List<>;
1395 };
1396 template <> struct node_from_variant_t<39> { using type = SgArrowStarOp; };
1397 
1398 // Class: AsmBasicString
1399 template <> struct describe_field_t<SgAsmBasicString,std::string,&SgAsmBasicString::p_string> {
1400  using parent = SgAsmBasicString;
1401  using field_type = std::string;
1402  static constexpr size_t position{0};
1403  static constexpr char const * const name{"string"};
1404  static constexpr char const * const typestr{"std::string"};
1405  static constexpr bool traverse{false};
1406  static constexpr auto mbr_ptr{&SgAsmBasicString::p_string};
1407  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1408  using bind = Desc<SgAsmBasicString, std::string SgAsmBasicString::*, &SgAsmBasicString::p_string>;
1409 };
1410 template <> struct describe_node_t<SgAsmBasicString> {
1411  using node = SgAsmBasicString;
1412  using base = SgAsmGenericString;
1413  static constexpr char const * const name{"AsmBasicString"};
1414  static constexpr unsigned long variant{46};
1415  static constexpr bool concrete{true};
1416  using subclasses_t = mp::List<>;
1418 };
1419 template <> struct node_from_variant_t<46> { using type = SgAsmBasicString; };
1420 
1421 // Class: AsmBinaryAdd
1422 template <> struct describe_node_t<SgAsmBinaryAdd> {
1423  using node = SgAsmBinaryAdd;
1424  using base = SgAsmBinaryExpression;
1425  static constexpr char const * const name{"AsmBinaryAdd"};
1426  static constexpr unsigned long variant{47};
1427  static constexpr bool concrete{true};
1428  using subclasses_t = mp::List<>;
1429  using fields_t = mp::List<>;
1430 };
1431 template <> struct node_from_variant_t<47> { using type = SgAsmBinaryAdd; };
1432 
1433 // Class: AsmBinaryAsr
1434 template <> struct describe_node_t<SgAsmBinaryAsr> {
1435  using node = SgAsmBinaryAsr;
1436  using base = SgAsmBinaryExpression;
1437  static constexpr char const * const name{"AsmBinaryAsr"};
1438  static constexpr unsigned long variant{50};
1439  static constexpr bool concrete{true};
1440  using subclasses_t = mp::List<>;
1441  using fields_t = mp::List<>;
1442 };
1443 template <> struct node_from_variant_t<50> { using type = SgAsmBinaryAsr; };
1444 
1445 // Class: AsmBinaryDivide
1446 template <> struct describe_node_t<SgAsmBinaryDivide> {
1447  using node = SgAsmBinaryDivide;
1448  using base = SgAsmBinaryExpression;
1449  static constexpr char const * const name{"AsmBinaryDivide"};
1450  static constexpr unsigned long variant{51};
1451  static constexpr bool concrete{true};
1452  using subclasses_t = mp::List<>;
1453  using fields_t = mp::List<>;
1454 };
1455 template <> struct node_from_variant_t<51> { using type = SgAsmBinaryDivide; };
1456 
1457 // Class: AsmBinaryExpression
1458 template <> struct describe_field_t<SgAsmBinaryExpression,SgAsmExpression*,&SgAsmBinaryExpression::p_lhs> {
1459  using parent = SgAsmBinaryExpression;
1460  using field_type = SgAsmExpression*;
1461  static constexpr size_t position{0};
1462  static constexpr char const * const name{"lhs"};
1463  static constexpr char const * const typestr{"SgAsmExpression*"};
1464  static constexpr bool traverse{true};
1465  static constexpr auto mbr_ptr{&SgAsmBinaryExpression::p_lhs};
1466  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1467  using bind = Desc<SgAsmBinaryExpression, SgAsmExpression* SgAsmBinaryExpression::*, &SgAsmBinaryExpression::p_lhs>;
1468 };
1469 template <> struct describe_field_t<SgAsmBinaryExpression,SgAsmExpression*,&SgAsmBinaryExpression::p_rhs> {
1470  using parent = SgAsmBinaryExpression;
1471  using field_type = SgAsmExpression*;
1472  static constexpr size_t position{1};
1473  static constexpr char const * const name{"rhs"};
1474  static constexpr char const * const typestr{"SgAsmExpression*"};
1475  static constexpr bool traverse{true};
1476  static constexpr auto mbr_ptr{&SgAsmBinaryExpression::p_rhs};
1477  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1478  using bind = Desc<SgAsmBinaryExpression, SgAsmExpression* SgAsmBinaryExpression::*, &SgAsmBinaryExpression::p_rhs>;
1479 };
1481  using node = SgAsmBinaryExpression;
1482  using base = SgAsmExpression;
1483  static constexpr char const * const name{"AsmBinaryExpression"};
1484  static constexpr unsigned long variant{52};
1485  static constexpr bool concrete{false};
1488 };
1489 template <> struct node_from_variant_t<52> { using type = SgAsmBinaryExpression; };
1490 
1491 // Class: AsmBinaryLsl
1492 template <> struct describe_node_t<SgAsmBinaryLsl> {
1493  using node = SgAsmBinaryLsl;
1494  using base = SgAsmBinaryExpression;
1495  static constexpr char const * const name{"AsmBinaryLsl"};
1496  static constexpr unsigned long variant{53};
1497  static constexpr bool concrete{true};
1498  using subclasses_t = mp::List<>;
1499  using fields_t = mp::List<>;
1500 };
1501 template <> struct node_from_variant_t<53> { using type = SgAsmBinaryLsl; };
1502 
1503 // Class: AsmBinaryLsr
1504 template <> struct describe_node_t<SgAsmBinaryLsr> {
1505  using node = SgAsmBinaryLsr;
1506  using base = SgAsmBinaryExpression;
1507  static constexpr char const * const name{"AsmBinaryLsr"};
1508  static constexpr unsigned long variant{54};
1509  static constexpr bool concrete{true};
1510  using subclasses_t = mp::List<>;
1511  using fields_t = mp::List<>;
1512 };
1513 template <> struct node_from_variant_t<54> { using type = SgAsmBinaryLsr; };
1514 
1515 // Class: AsmBinaryMod
1516 template <> struct describe_node_t<SgAsmBinaryMod> {
1517  using node = SgAsmBinaryMod;
1518  using base = SgAsmBinaryExpression;
1519  static constexpr char const * const name{"AsmBinaryMod"};
1520  static constexpr unsigned long variant{55};
1521  static constexpr bool concrete{true};
1522  using subclasses_t = mp::List<>;
1523  using fields_t = mp::List<>;
1524 };
1525 template <> struct node_from_variant_t<55> { using type = SgAsmBinaryMod; };
1526 
1527 // Class: AsmBinaryMsl
1528 template <> struct describe_node_t<SgAsmBinaryMsl> {
1529  using node = SgAsmBinaryMsl;
1530  using base = SgAsmBinaryExpression;
1531  static constexpr char const * const name{"AsmBinaryMsl"};
1532  static constexpr unsigned long variant{56};
1533  static constexpr bool concrete{true};
1534  using subclasses_t = mp::List<>;
1535  using fields_t = mp::List<>;
1536 };
1537 template <> struct node_from_variant_t<56> { using type = SgAsmBinaryMsl; };
1538 
1539 // Class: AsmBinaryMultiply
1541  using node = SgAsmBinaryMultiply;
1542  using base = SgAsmBinaryExpression;
1543  static constexpr char const * const name{"AsmBinaryMultiply"};
1544  static constexpr unsigned long variant{57};
1545  static constexpr bool concrete{true};
1546  using subclasses_t = mp::List<>;
1547  using fields_t = mp::List<>;
1548 };
1549 template <> struct node_from_variant_t<57> { using type = SgAsmBinaryMultiply; };
1550 
1551 // Class: AsmBinaryRor
1552 template <> struct describe_node_t<SgAsmBinaryRor> {
1553  using node = SgAsmBinaryRor;
1554  using base = SgAsmBinaryExpression;
1555  static constexpr char const * const name{"AsmBinaryRor"};
1556  static constexpr unsigned long variant{58};
1557  static constexpr bool concrete{true};
1558  using subclasses_t = mp::List<>;
1559  using fields_t = mp::List<>;
1560 };
1561 template <> struct node_from_variant_t<58> { using type = SgAsmBinaryRor; };
1562 
1563 // Class: AsmBinarySubtract
1565  using node = SgAsmBinarySubtract;
1566  using base = SgAsmBinaryExpression;
1567  static constexpr char const * const name{"AsmBinarySubtract"};
1568  static constexpr unsigned long variant{59};
1569  static constexpr bool concrete{true};
1570  using subclasses_t = mp::List<>;
1571  using fields_t = mp::List<>;
1572 };
1573 template <> struct node_from_variant_t<59> { using type = SgAsmBinarySubtract; };
1574 
1575 // Class: AsmBlock
1576 template <> struct describe_field_t<SgAsmBlock,rose_addr_t,&SgAsmBlock::p_id> {
1577  using parent = SgAsmBlock;
1578  using field_type = rose_addr_t;
1579  static constexpr size_t position{0};
1580  static constexpr char const * const name{"id"};
1581  static constexpr char const * const typestr{"rose_addr_t"};
1582  static constexpr bool traverse{false};
1583  static constexpr auto mbr_ptr{&SgAsmBlock::p_id};
1584  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1585  using bind = Desc<SgAsmBlock, rose_addr_t SgAsmBlock::*, &SgAsmBlock::p_id>;
1586 };
1587 template <> struct describe_field_t<SgAsmBlock,unsigned,&SgAsmBlock::p_reason> {
1588  using parent = SgAsmBlock;
1589  using field_type = unsigned;
1590  static constexpr size_t position{1};
1591  static constexpr char const * const name{"reason"};
1592  static constexpr char const * const typestr{"unsigned"};
1593  static constexpr bool traverse{false};
1594  static constexpr auto mbr_ptr{&SgAsmBlock::p_reason};
1595  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1596  using bind = Desc<SgAsmBlock, unsigned SgAsmBlock::*, &SgAsmBlock::p_reason>;
1597 };
1598 template <> struct describe_field_t<SgAsmBlock,SgAsmStatementPtrList,&SgAsmBlock::p_statementList> {
1599  using parent = SgAsmBlock;
1600  using field_type = SgAsmStatementPtrList;
1601  static constexpr size_t position{2};
1602  static constexpr char const * const name{"statementList"};
1603  static constexpr char const * const typestr{"SgAsmStatementPtrList"};
1604  static constexpr bool traverse{true};
1605  static constexpr auto mbr_ptr{&SgAsmBlock::p_statementList};
1606  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1607  using bind = Desc<SgAsmBlock, SgAsmStatementPtrList SgAsmBlock::*, &SgAsmBlock::p_statementList>;
1608 };
1609 template <> struct describe_field_t<SgAsmBlock,SgAsmIntegerValuePtrList,&SgAsmBlock::p_successors> {
1610  using parent = SgAsmBlock;
1611  using field_type = SgAsmIntegerValuePtrList;
1612  static constexpr size_t position{3};
1613  static constexpr char const * const name{"successors"};
1614  static constexpr char const * const typestr{"SgAsmIntegerValuePtrList"};
1615  static constexpr bool traverse{false};
1616  static constexpr auto mbr_ptr{&SgAsmBlock::p_successors};
1617  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1618  using bind = Desc<SgAsmBlock, SgAsmIntegerValuePtrList SgAsmBlock::*, &SgAsmBlock::p_successors>;
1619 };
1620 template <> struct describe_field_t<SgAsmBlock,bool,&SgAsmBlock::p_successors_complete> {
1621  using parent = SgAsmBlock;
1622  using field_type = bool;
1623  static constexpr size_t position{4};
1624  static constexpr char const * const name{"successors_complete"};
1625  static constexpr char const * const typestr{"bool"};
1626  static constexpr bool traverse{false};
1627  static constexpr auto mbr_ptr{&SgAsmBlock::p_successors_complete};
1628  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1629  using bind = Desc<SgAsmBlock, bool SgAsmBlock::*, &SgAsmBlock::p_successors_complete>;
1630 };
1631 template <> struct describe_field_t<SgAsmBlock,SgAsmBlock*,&SgAsmBlock::p_immediate_dominator> {
1632  using parent = SgAsmBlock;
1633  using field_type = SgAsmBlock*;
1634  static constexpr size_t position{5};
1635  static constexpr char const * const name{"immediate_dominator"};
1636  static constexpr char const * const typestr{"SgAsmBlock*"};
1637  static constexpr bool traverse{false};
1638  static constexpr auto mbr_ptr{&SgAsmBlock::p_immediate_dominator};
1639  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1640  using bind = Desc<SgAsmBlock, SgAsmBlock* SgAsmBlock::*, &SgAsmBlock::p_immediate_dominator>;
1641 };
1642 template <> struct describe_field_t<SgAsmBlock,size_t,&SgAsmBlock::p_cached_vertex> {
1643  using parent = SgAsmBlock;
1644  using field_type = size_t;
1645  static constexpr size_t position{6};
1646  static constexpr char const * const name{"cached_vertex"};
1647  static constexpr char const * const typestr{"size_t"};
1648  static constexpr bool traverse{false};
1649  static constexpr auto mbr_ptr{&SgAsmBlock::p_cached_vertex};
1650  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1651  using bind = Desc<SgAsmBlock, size_t SgAsmBlock::*, &SgAsmBlock::p_cached_vertex>;
1652 };
1653 template <> struct describe_field_t<SgAsmBlock,double,&SgAsmBlock::p_code_likelihood> {
1654  using parent = SgAsmBlock;
1655  using field_type = double;
1656  static constexpr size_t position{7};
1657  static constexpr char const * const name{"code_likelihood"};
1658  static constexpr char const * const typestr{"double"};
1659  static constexpr bool traverse{false};
1660  static constexpr auto mbr_ptr{&SgAsmBlock::p_code_likelihood};
1661  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1662  using bind = Desc<SgAsmBlock, double SgAsmBlock::*, &SgAsmBlock::p_code_likelihood>;
1663 };
1664 template <> struct describe_field_t<SgAsmBlock,int64_t,&SgAsmBlock::p_stackDeltaOut> {
1665  using parent = SgAsmBlock;
1666  using field_type = int64_t;
1667  static constexpr size_t position{8};
1668  static constexpr char const * const name{"stackDeltaOut"};
1669  static constexpr char const * const typestr{"int64_t"};
1670  static constexpr bool traverse{false};
1671  static constexpr auto mbr_ptr{&SgAsmBlock::p_stackDeltaOut};
1672  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1673  using bind = Desc<SgAsmBlock, int64_t SgAsmBlock::*, &SgAsmBlock::p_stackDeltaOut>;
1674 };
1675 template <> struct describe_node_t<SgAsmBlock> {
1676  using node = SgAsmBlock;
1677  using base = SgAsmStatement;
1678  static constexpr char const * const name{"AsmBlock"};
1679  static constexpr unsigned long variant{62};
1680  static constexpr bool concrete{true};
1681  using subclasses_t = mp::List<>;
1683 };
1684 template <> struct node_from_variant_t<62> { using type = SgAsmBlock; };
1685 
1686 // Class: AsmCoffStrtab
1687 template <> struct describe_node_t<SgAsmCoffStrtab> {
1688  using node = SgAsmCoffStrtab;
1689  using base = SgAsmGenericStrtab;
1690  static constexpr char const * const name{"AsmCoffStrtab"};
1691  static constexpr unsigned long variant{63};
1692  static constexpr bool concrete{true};
1693  using subclasses_t = mp::List<>;
1694  using fields_t = mp::List<>;
1695 };
1696 template <> struct node_from_variant_t<63> { using type = SgAsmCoffStrtab; };
1697 
1698 // Class: AsmCoffSymbol
1699 template <> struct describe_field_t<SgAsmCoffSymbol,std::string,&SgAsmCoffSymbol::p_st_name> {
1700  using parent = SgAsmCoffSymbol;
1701  using field_type = std::string;
1702  static constexpr size_t position{0};
1703  static constexpr char const * const name{"st_name"};
1704  static constexpr char const * const typestr{"std::string"};
1705  static constexpr bool traverse{false};
1706  static constexpr auto mbr_ptr{&SgAsmCoffSymbol::p_st_name};
1707  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1708  using bind = Desc<SgAsmCoffSymbol, std::string SgAsmCoffSymbol::*, &SgAsmCoffSymbol::p_st_name>;
1709 };
1710 template <> struct describe_field_t<SgAsmCoffSymbol,rose_addr_t,&SgAsmCoffSymbol::p_st_name_offset> {
1711  using parent = SgAsmCoffSymbol;
1712  using field_type = rose_addr_t;
1713  static constexpr size_t position{1};
1714  static constexpr char const * const name{"st_name_offset"};
1715  static constexpr char const * const typestr{"rose_addr_t"};
1716  static constexpr bool traverse{false};
1717  static constexpr auto mbr_ptr{&SgAsmCoffSymbol::p_st_name_offset};
1718  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1719  using bind = Desc<SgAsmCoffSymbol, rose_addr_t SgAsmCoffSymbol::*, &SgAsmCoffSymbol::p_st_name_offset>;
1720 };
1721 template <> struct describe_field_t<SgAsmCoffSymbol,int,&SgAsmCoffSymbol::p_st_section_num> {
1722  using parent = SgAsmCoffSymbol;
1723  using field_type = int;
1724  static constexpr size_t position{2};
1725  static constexpr char const * const name{"st_section_num"};
1726  static constexpr char const * const typestr{"int"};
1727  static constexpr bool traverse{false};
1728  static constexpr auto mbr_ptr{&SgAsmCoffSymbol::p_st_section_num};
1729  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1730  using bind = Desc<SgAsmCoffSymbol, int SgAsmCoffSymbol::*, &SgAsmCoffSymbol::p_st_section_num>;
1731 };
1732 template <> struct describe_field_t<SgAsmCoffSymbol,unsigned,&SgAsmCoffSymbol::p_st_type> {
1733  using parent = SgAsmCoffSymbol;
1734  using field_type = unsigned;
1735  static constexpr size_t position{3};
1736  static constexpr char const * const name{"st_type"};
1737  static constexpr char const * const typestr{"unsigned"};
1738  static constexpr bool traverse{false};
1739  static constexpr auto mbr_ptr{&SgAsmCoffSymbol::p_st_type};
1740  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1741  using bind = Desc<SgAsmCoffSymbol, unsigned SgAsmCoffSymbol::*, &SgAsmCoffSymbol::p_st_type>;
1742 };
1743 template <> struct describe_field_t<SgAsmCoffSymbol,unsigned,&SgAsmCoffSymbol::p_st_storage_class> {
1744  using parent = SgAsmCoffSymbol;
1745  using field_type = unsigned;
1746  static constexpr size_t position{4};
1747  static constexpr char const * const name{"st_storage_class"};
1748  static constexpr char const * const typestr{"unsigned"};
1749  static constexpr bool traverse{false};
1750  static constexpr auto mbr_ptr{&SgAsmCoffSymbol::p_st_storage_class};
1751  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1752  using bind = Desc<SgAsmCoffSymbol, unsigned SgAsmCoffSymbol::*, &SgAsmCoffSymbol::p_st_storage_class>;
1753 };
1754 template <> struct describe_field_t<SgAsmCoffSymbol,unsigned,&SgAsmCoffSymbol::p_st_num_aux_entries> {
1755  using parent = SgAsmCoffSymbol;
1756  using field_type = unsigned;
1757  static constexpr size_t position{5};
1758  static constexpr char const * const name{"st_num_aux_entries"};
1759  static constexpr char const * const typestr{"unsigned"};
1760  static constexpr bool traverse{false};
1761  static constexpr auto mbr_ptr{&SgAsmCoffSymbol::p_st_num_aux_entries};
1762  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1763  using bind = Desc<SgAsmCoffSymbol, unsigned SgAsmCoffSymbol::*, &SgAsmCoffSymbol::p_st_num_aux_entries>;
1764 };
1765 template <> struct describe_field_t<SgAsmCoffSymbol,SgUnsignedCharList,&SgAsmCoffSymbol::p_aux_data> {
1766  using parent = SgAsmCoffSymbol;
1767  using field_type = SgUnsignedCharList;
1768  static constexpr size_t position{6};
1769  static constexpr char const * const name{"aux_data"};
1770  static constexpr char const * const typestr{"SgUnsignedCharList"};
1771  static constexpr bool traverse{false};
1772  static constexpr auto mbr_ptr{&SgAsmCoffSymbol::p_aux_data};
1773  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1774  using bind = Desc<SgAsmCoffSymbol, SgUnsignedCharList SgAsmCoffSymbol::*, &SgAsmCoffSymbol::p_aux_data>;
1775 };
1776 template <> struct describe_node_t<SgAsmCoffSymbol> {
1777  using node = SgAsmCoffSymbol;
1778  using base = SgAsmGenericSymbol;
1779  static constexpr char const * const name{"AsmCoffSymbol"};
1780  static constexpr unsigned long variant{64};
1781  static constexpr bool concrete{true};
1782  using subclasses_t = mp::List<>;
1784 };
1785 template <> struct node_from_variant_t<64> { using type = SgAsmCoffSymbol; };
1786 
1787 // Class: AsmCoffSymbolList
1788 template <> struct describe_field_t<SgAsmCoffSymbolList,SgAsmCoffSymbolPtrList,&SgAsmCoffSymbolList::p_symbols> {
1789  using parent = SgAsmCoffSymbolList;
1790  using field_type = SgAsmCoffSymbolPtrList;
1791  static constexpr size_t position{0};
1792  static constexpr char const * const name{"symbols"};
1793  static constexpr char const * const typestr{"SgAsmCoffSymbolPtrList"};
1794  static constexpr bool traverse{true};
1795  static constexpr auto mbr_ptr{&SgAsmCoffSymbolList::p_symbols};
1796  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1797  using bind = Desc<SgAsmCoffSymbolList, SgAsmCoffSymbolPtrList SgAsmCoffSymbolList::*, &SgAsmCoffSymbolList::p_symbols>;
1798 };
1800  using node = SgAsmCoffSymbolList;
1802  static constexpr char const * const name{"AsmCoffSymbolList"};
1803  static constexpr unsigned long variant{65};
1804  static constexpr bool concrete{true};
1805  using subclasses_t = mp::List<>;
1807 };
1808 template <> struct node_from_variant_t<65> { using type = SgAsmCoffSymbolList; };
1809 
1810 // Class: AsmCoffSymbolTable
1811 template <> struct describe_field_t<SgAsmCoffSymbolTable,SgAsmGenericSection*,&SgAsmCoffSymbolTable::p_strtab> {
1812  using parent = SgAsmCoffSymbolTable;
1814  static constexpr size_t position{0};
1815  static constexpr char const * const name{"strtab"};
1816  static constexpr char const * const typestr{"SgAsmGenericSection*"};
1817  static constexpr bool traverse{false};
1818  static constexpr auto mbr_ptr{&SgAsmCoffSymbolTable::p_strtab};
1819  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1820  using bind = Desc<SgAsmCoffSymbolTable, SgAsmGenericSection* SgAsmCoffSymbolTable::*, &SgAsmCoffSymbolTable::p_strtab>;
1821 };
1822 template <> struct describe_field_t<SgAsmCoffSymbolTable,SgAsmCoffSymbolList*,&SgAsmCoffSymbolTable::p_symbols> {
1823  using parent = SgAsmCoffSymbolTable;
1825  static constexpr size_t position{1};
1826  static constexpr char const * const name{"symbols"};
1827  static constexpr char const * const typestr{"SgAsmCoffSymbolList*"};
1828  static constexpr bool traverse{true};
1829  static constexpr auto mbr_ptr{&SgAsmCoffSymbolTable::p_symbols};
1830  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1831  using bind = Desc<SgAsmCoffSymbolTable, SgAsmCoffSymbolList* SgAsmCoffSymbolTable::*, &SgAsmCoffSymbolTable::p_symbols>;
1832 };
1834  using node = SgAsmCoffSymbolTable;
1835  using base = SgAsmGenericSection;
1836  static constexpr char const * const name{"AsmCoffSymbolTable"};
1837  static constexpr unsigned long variant{66};
1838  static constexpr bool concrete{true};
1839  using subclasses_t = mp::List<>;
1841 };
1842 template <> struct node_from_variant_t<66> { using type = SgAsmCoffSymbolTable; };
1843 
1844 // Class: AsmCommonSubExpression
1845 template <> struct describe_field_t<SgAsmCommonSubExpression,SgAsmExpression*,&SgAsmCommonSubExpression::p_subexpression> {
1846  using parent = SgAsmCommonSubExpression;
1847  using field_type = SgAsmExpression*;
1848  static constexpr size_t position{0};
1849  static constexpr char const * const name{"subexpression"};
1850  static constexpr char const * const typestr{"SgAsmExpression*"};
1851  static constexpr bool traverse{true};
1852  static constexpr auto mbr_ptr{&SgAsmCommonSubExpression::p_subexpression};
1853  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1854  using bind = Desc<SgAsmCommonSubExpression, SgAsmExpression* SgAsmCommonSubExpression::*, &SgAsmCommonSubExpression::p_subexpression>;
1855 };
1856 template <> struct describe_node_t<SgAsmCommonSubExpression> {
1857  using node = SgAsmCommonSubExpression;
1858  using base = SgAsmExpression;
1859  static constexpr char const * const name{"AsmCommonSubExpression"};
1860  static constexpr unsigned long variant{67};
1861  static constexpr bool concrete{true};
1862  using subclasses_t = mp::List<>;
1864 };
1865 template <> struct node_from_variant_t<67> { using type = SgAsmCommonSubExpression; };
1866 
1867 // Class: AsmControlFlagsExpression
1868 template <> struct describe_field_t<SgAsmControlFlagsExpression,unsigned long,&SgAsmControlFlagsExpression::p_bit_flags> {
1870  using field_type = unsigned long;
1871  static constexpr size_t position{0};
1872  static constexpr char const * const name{"bit_flags"};
1873  static constexpr char const * const typestr{"unsigned long"};
1874  static constexpr bool traverse{false};
1875  static constexpr auto mbr_ptr{&SgAsmControlFlagsExpression::p_bit_flags};
1876  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1877  using bind = Desc<SgAsmControlFlagsExpression, unsigned long SgAsmControlFlagsExpression::*, &SgAsmControlFlagsExpression::p_bit_flags>;
1878 };
1881  using base = SgAsmExpression;
1882  static constexpr char const * const name{"AsmControlFlagsExpression"};
1883  static constexpr unsigned long variant{68};
1884  static constexpr bool concrete{true};
1885  using subclasses_t = mp::List<>;
1887 };
1888 template <> struct node_from_variant_t<68> { using type = SgAsmControlFlagsExpression; };
1889 
1890 // Class: AsmConstantExpression
1891 template <> struct describe_field_t<SgAsmConstantExpression,Sawyer::Container::BitVector,&SgAsmConstantExpression::p_bitVector> {
1894  static constexpr size_t position{0};
1895  static constexpr char const * const name{"bitVector"};
1896  static constexpr char const * const typestr{"Sawyer::Container::BitVector"};
1897  static constexpr bool traverse{false};
1898  static constexpr auto mbr_ptr{&SgAsmConstantExpression::p_bitVector};
1899  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1900  using bind = Desc<SgAsmConstantExpression, Sawyer::Container::BitVector SgAsmConstantExpression::*, &SgAsmConstantExpression::p_bitVector>;
1901 };
1903  using node = SgAsmConstantExpression;
1904  using base = SgAsmValueExpression;
1905  static constexpr char const * const name{"AsmConstantExpression"};
1906  static constexpr unsigned long variant{69};
1907  static constexpr bool concrete{false};
1910 };
1911 template <> struct node_from_variant_t<69> { using type = SgAsmConstantExpression; };
1912 
1913 // Class: AsmDOSExtendedHeader
1914 template <> struct describe_field_t<SgAsmDOSExtendedHeader,unsigned,&SgAsmDOSExtendedHeader::p_e_res1> {
1916  using field_type = unsigned;
1917  static constexpr size_t position{0};
1918  static constexpr char const * const name{"e_res1"};
1919  static constexpr char const * const typestr{"unsigned"};
1920  static constexpr bool traverse{false};
1921  static constexpr auto mbr_ptr{&SgAsmDOSExtendedHeader::p_e_res1};
1922  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1923  using bind = Desc<SgAsmDOSExtendedHeader, unsigned SgAsmDOSExtendedHeader::*, &SgAsmDOSExtendedHeader::p_e_res1>;
1924 };
1925 template <> struct describe_field_t<SgAsmDOSExtendedHeader,unsigned,&SgAsmDOSExtendedHeader::p_e_oemid> {
1927  using field_type = unsigned;
1928  static constexpr size_t position{1};
1929  static constexpr char const * const name{"e_oemid"};
1930  static constexpr char const * const typestr{"unsigned"};
1931  static constexpr bool traverse{false};
1932  static constexpr auto mbr_ptr{&SgAsmDOSExtendedHeader::p_e_oemid};
1933  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1934  using bind = Desc<SgAsmDOSExtendedHeader, unsigned SgAsmDOSExtendedHeader::*, &SgAsmDOSExtendedHeader::p_e_oemid>;
1935 };
1936 template <> struct describe_field_t<SgAsmDOSExtendedHeader,unsigned,&SgAsmDOSExtendedHeader::p_e_oeminfo> {
1938  using field_type = unsigned;
1939  static constexpr size_t position{2};
1940  static constexpr char const * const name{"e_oeminfo"};
1941  static constexpr char const * const typestr{"unsigned"};
1942  static constexpr bool traverse{false};
1943  static constexpr auto mbr_ptr{&SgAsmDOSExtendedHeader::p_e_oeminfo};
1944  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1945  using bind = Desc<SgAsmDOSExtendedHeader, unsigned SgAsmDOSExtendedHeader::*, &SgAsmDOSExtendedHeader::p_e_oeminfo>;
1946 };
1947 template <> struct describe_field_t<SgAsmDOSExtendedHeader,unsigned,&SgAsmDOSExtendedHeader::p_e_res2> {
1949  using field_type = unsigned;
1950  static constexpr size_t position{3};
1951  static constexpr char const * const name{"e_res2"};
1952  static constexpr char const * const typestr{"unsigned"};
1953  static constexpr bool traverse{false};
1954  static constexpr auto mbr_ptr{&SgAsmDOSExtendedHeader::p_e_res2};
1955  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1956  using bind = Desc<SgAsmDOSExtendedHeader, unsigned SgAsmDOSExtendedHeader::*, &SgAsmDOSExtendedHeader::p_e_res2>;
1957 };
1958 template <> struct describe_field_t<SgAsmDOSExtendedHeader,unsigned,&SgAsmDOSExtendedHeader::p_e_res3> {
1960  using field_type = unsigned;
1961  static constexpr size_t position{4};
1962  static constexpr char const * const name{"e_res3"};
1963  static constexpr char const * const typestr{"unsigned"};
1964  static constexpr bool traverse{false};
1965  static constexpr auto mbr_ptr{&SgAsmDOSExtendedHeader::p_e_res3};
1966  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1967  using bind = Desc<SgAsmDOSExtendedHeader, unsigned SgAsmDOSExtendedHeader::*, &SgAsmDOSExtendedHeader::p_e_res3>;
1968 };
1969 template <> struct describe_field_t<SgAsmDOSExtendedHeader,unsigned,&SgAsmDOSExtendedHeader::p_e_res4> {
1971  using field_type = unsigned;
1972  static constexpr size_t position{5};
1973  static constexpr char const * const name{"e_res4"};
1974  static constexpr char const * const typestr{"unsigned"};
1975  static constexpr bool traverse{false};
1976  static constexpr auto mbr_ptr{&SgAsmDOSExtendedHeader::p_e_res4};
1977  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1978  using bind = Desc<SgAsmDOSExtendedHeader, unsigned SgAsmDOSExtendedHeader::*, &SgAsmDOSExtendedHeader::p_e_res4>;
1979 };
1980 template <> struct describe_field_t<SgAsmDOSExtendedHeader,unsigned,&SgAsmDOSExtendedHeader::p_e_res5> {
1982  using field_type = unsigned;
1983  static constexpr size_t position{6};
1984  static constexpr char const * const name{"e_res5"};
1985  static constexpr char const * const typestr{"unsigned"};
1986  static constexpr bool traverse{false};
1987  static constexpr auto mbr_ptr{&SgAsmDOSExtendedHeader::p_e_res5};
1988  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1989  using bind = Desc<SgAsmDOSExtendedHeader, unsigned SgAsmDOSExtendedHeader::*, &SgAsmDOSExtendedHeader::p_e_res5>;
1990 };
1991 template <> struct describe_field_t<SgAsmDOSExtendedHeader,unsigned,&SgAsmDOSExtendedHeader::p_e_res6> {
1993  using field_type = unsigned;
1994  static constexpr size_t position{7};
1995  static constexpr char const * const name{"e_res6"};
1996  static constexpr char const * const typestr{"unsigned"};
1997  static constexpr bool traverse{false};
1998  static constexpr auto mbr_ptr{&SgAsmDOSExtendedHeader::p_e_res6};
1999  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2000  using bind = Desc<SgAsmDOSExtendedHeader, unsigned SgAsmDOSExtendedHeader::*, &SgAsmDOSExtendedHeader::p_e_res6>;
2001 };
2002 template <> struct describe_field_t<SgAsmDOSExtendedHeader,rose_addr_t,&SgAsmDOSExtendedHeader::p_e_lfanew> {
2004  using field_type = rose_addr_t;
2005  static constexpr size_t position{8};
2006  static constexpr char const * const name{"e_lfanew"};
2007  static constexpr char const * const typestr{"rose_addr_t"};
2008  static constexpr bool traverse{false};
2009  static constexpr auto mbr_ptr{&SgAsmDOSExtendedHeader::p_e_lfanew};
2010  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2011  using bind = Desc<SgAsmDOSExtendedHeader, rose_addr_t SgAsmDOSExtendedHeader::*, &SgAsmDOSExtendedHeader::p_e_lfanew>;
2012 };
2014  using node = SgAsmDOSExtendedHeader;
2015  using base = SgAsmGenericSection;
2016  static constexpr char const * const name{"AsmDOSExtendedHeader"};
2017  static constexpr unsigned long variant{70};
2018  static constexpr bool concrete{true};
2019  using subclasses_t = mp::List<>;
2021 };
2022 template <> struct node_from_variant_t<70> { using type = SgAsmDOSExtendedHeader; };
2023 
2024 // Class: AsmDOSFileHeader
2025 template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_last_page_size> {
2026  using parent = SgAsmDOSFileHeader;
2027  using field_type = uint16_t;
2028  static constexpr size_t position{0};
2029  static constexpr char const * const name{"e_last_page_size"};
2030  static constexpr char const * const typestr{"uint16_t"};
2031  static constexpr bool traverse{false};
2032  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_last_page_size};
2033  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2034  using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_last_page_size>;
2035 };
2036 template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_total_pages> {
2037  using parent = SgAsmDOSFileHeader;
2038  using field_type = uint16_t;
2039  static constexpr size_t position{1};
2040  static constexpr char const * const name{"e_total_pages"};
2041  static constexpr char const * const typestr{"uint16_t"};
2042  static constexpr bool traverse{false};
2043  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_total_pages};
2044  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2045  using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_total_pages>;
2046 };
2047 template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_nrelocs> {
2048  using parent = SgAsmDOSFileHeader;
2049  using field_type = uint16_t;
2050  static constexpr size_t position{2};
2051  static constexpr char const * const name{"e_nrelocs"};
2052  static constexpr char const * const typestr{"uint16_t"};
2053  static constexpr bool traverse{false};
2054  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_nrelocs};
2055  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2056  using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_nrelocs>;
2057 };
2058 template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_header_paragraphs> {
2059  using parent = SgAsmDOSFileHeader;
2060  using field_type = uint16_t;
2061  static constexpr size_t position{3};
2062  static constexpr char const * const name{"e_header_paragraphs"};
2063  static constexpr char const * const typestr{"uint16_t"};
2064  static constexpr bool traverse{false};
2065  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_header_paragraphs};
2066  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2067  using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_header_paragraphs>;
2068 };
2069 template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_minalloc> {
2070  using parent = SgAsmDOSFileHeader;
2071  using field_type = uint16_t;
2072  static constexpr size_t position{4};
2073  static constexpr char const * const name{"e_minalloc"};
2074  static constexpr char const * const typestr{"uint16_t"};
2075  static constexpr bool traverse{false};
2076  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_minalloc};
2077  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2078  using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_minalloc>;
2079 };
2080 template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_maxalloc> {
2081  using parent = SgAsmDOSFileHeader;
2082  using field_type = uint16_t;
2083  static constexpr size_t position{5};
2084  static constexpr char const * const name{"e_maxalloc"};
2085  static constexpr char const * const typestr{"uint16_t"};
2086  static constexpr bool traverse{false};
2087  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_maxalloc};
2088  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2089  using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_maxalloc>;
2090 };
2091 template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_ss> {
2092  using parent = SgAsmDOSFileHeader;
2093  using field_type = uint16_t;
2094  static constexpr size_t position{6};
2095  static constexpr char const * const name{"e_ss"};
2096  static constexpr char const * const typestr{"uint16_t"};
2097  static constexpr bool traverse{false};
2098  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_ss};
2099  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2100  using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_ss>;
2101 };
2102 template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_sp> {
2103  using parent = SgAsmDOSFileHeader;
2104  using field_type = uint16_t;
2105  static constexpr size_t position{7};
2106  static constexpr char const * const name{"e_sp"};
2107  static constexpr char const * const typestr{"uint16_t"};
2108  static constexpr bool traverse{false};
2109  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_sp};
2110  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2111  using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_sp>;
2112 };
2113 template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_cksum> {
2114  using parent = SgAsmDOSFileHeader;
2115  using field_type = uint16_t;
2116  static constexpr size_t position{8};
2117  static constexpr char const * const name{"e_cksum"};
2118  static constexpr char const * const typestr{"uint16_t"};
2119  static constexpr bool traverse{false};
2120  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_cksum};
2121  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2122  using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_cksum>;
2123 };
2124 template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_ip> {
2125  using parent = SgAsmDOSFileHeader;
2126  using field_type = uint16_t;
2127  static constexpr size_t position{9};
2128  static constexpr char const * const name{"e_ip"};
2129  static constexpr char const * const typestr{"uint16_t"};
2130  static constexpr bool traverse{false};
2131  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_ip};
2132  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2133  using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_ip>;
2134 };
2135 template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_cs> {
2136  using parent = SgAsmDOSFileHeader;
2137  using field_type = uint16_t;
2138  static constexpr size_t position{10};
2139  static constexpr char const * const name{"e_cs"};
2140  static constexpr char const * const typestr{"uint16_t"};
2141  static constexpr bool traverse{false};
2142  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_cs};
2143  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2144  using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_cs>;
2145 };
2146 template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_overlay> {
2147  using parent = SgAsmDOSFileHeader;
2148  using field_type = uint16_t;
2149  static constexpr size_t position{11};
2150  static constexpr char const * const name{"e_overlay"};
2151  static constexpr char const * const typestr{"uint16_t"};
2152  static constexpr bool traverse{false};
2153  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_overlay};
2154  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2155  using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_overlay>;
2156 };
2157 template <> struct describe_field_t<SgAsmDOSFileHeader,rose_addr_t,&SgAsmDOSFileHeader::p_e_relocs_offset> {
2158  using parent = SgAsmDOSFileHeader;
2159  using field_type = rose_addr_t;
2160  static constexpr size_t position{12};
2161  static constexpr char const * const name{"e_relocs_offset"};
2162  static constexpr char const * const typestr{"rose_addr_t"};
2163  static constexpr bool traverse{false};
2164  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_relocs_offset};
2165  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2166  using bind = Desc<SgAsmDOSFileHeader, rose_addr_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_relocs_offset>;
2167 };
2168 template <> struct describe_field_t<SgAsmDOSFileHeader,unsigned,&SgAsmDOSFileHeader::p_e_res1> {
2169  using parent = SgAsmDOSFileHeader;
2170  using field_type = unsigned;
2171  static constexpr size_t position{13};
2172  static constexpr char const * const name{"e_res1"};
2173  static constexpr char const * const typestr{"unsigned"};
2174  static constexpr bool traverse{false};
2175  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_res1};
2176  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2177  using bind = Desc<SgAsmDOSFileHeader, unsigned SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_res1>;
2178 };
2179 template <> struct describe_field_t<SgAsmDOSFileHeader,SgAsmGenericSection*,&SgAsmDOSFileHeader::p_relocs> {
2180  using parent = SgAsmDOSFileHeader;
2182  static constexpr size_t position{14};
2183  static constexpr char const * const name{"relocs"};
2184  static constexpr char const * const typestr{"SgAsmGenericSection*"};
2185  static constexpr bool traverse{true};
2186  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_relocs};
2187  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2188  using bind = Desc<SgAsmDOSFileHeader, SgAsmGenericSection* SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_relocs>;
2189 };
2190 template <> struct describe_field_t<SgAsmDOSFileHeader,SgAsmGenericSection*,&SgAsmDOSFileHeader::p_rm_section> {
2191  using parent = SgAsmDOSFileHeader;
2193  static constexpr size_t position{15};
2194  static constexpr char const * const name{"rm_section"};
2195  static constexpr char const * const typestr{"SgAsmGenericSection*"};
2196  static constexpr bool traverse{false};
2197  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_rm_section};
2198  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2199  using bind = Desc<SgAsmDOSFileHeader, SgAsmGenericSection* SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_rm_section>;
2200 };
2202  using node = SgAsmDOSFileHeader;
2203  using base = SgAsmGenericHeader;
2204  static constexpr char const * const name{"AsmDOSFileHeader"};
2205  static constexpr unsigned long variant{71};
2206  static constexpr bool concrete{true};
2207  using subclasses_t = mp::List<>;
2209 };
2210 template <> struct node_from_variant_t<71> { using type = SgAsmDOSFileHeader; };
2211 
2212 // Class: AsmSynthesizedDataStructureDeclaration
2216  static constexpr char const * const name{"AsmSynthesizedDataStructureDeclaration"};
2217  static constexpr unsigned long variant{72};
2218  static constexpr bool concrete{true};
2219  using subclasses_t = mp::List<>;
2220  using fields_t = mp::List<>;
2221 };
2222 template <> struct node_from_variant_t<72> { using type = SgAsmSynthesizedDataStructureDeclaration; };
2223 
2224 // Class: AsmSynthesizedDeclaration
2227  using base = SgAsmStatement;
2228  static constexpr char const * const name{"AsmSynthesizedDeclaration"};
2229  static constexpr unsigned long variant{73};
2230  static constexpr bool concrete{false};
2232  using fields_t = mp::List<>;
2233 };
2234 template <> struct node_from_variant_t<73> { using type = SgAsmSynthesizedDeclaration; };
2235 
2236 // Class: AsmDirectRegisterExpression
2240  static constexpr char const * const name{"AsmDirectRegisterExpression"};
2241  static constexpr unsigned long variant{74};
2242  static constexpr bool concrete{true};
2243  using subclasses_t = mp::List<>;
2244  using fields_t = mp::List<>;
2245 };
2246 template <> struct node_from_variant_t<74> { using type = SgAsmDirectRegisterExpression; };
2247 
2248 // Class: AsmDwarfAccessDeclaration
2251  using base = SgAsmDwarfConstruct;
2252  static constexpr char const * const name{"AsmDwarfAccessDeclaration"};
2253  static constexpr unsigned long variant{75};
2254  static constexpr bool concrete{true};
2255  using subclasses_t = mp::List<>;
2256  using fields_t = mp::List<>;
2257 };
2258 template <> struct node_from_variant_t<75> { using type = SgAsmDwarfAccessDeclaration; };
2259 
2260 // Class: AsmDwarfArrayType
2261 template <> struct describe_field_t<SgAsmDwarfArrayType,SgAsmDwarfConstructList*,&SgAsmDwarfArrayType::p_body> {
2262  using parent = SgAsmDwarfArrayType;
2264  static constexpr size_t position{0};
2265  static constexpr char const * const name{"body"};
2266  static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
2267  static constexpr bool traverse{true};
2268  static constexpr auto mbr_ptr{&SgAsmDwarfArrayType::p_body};
2269  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2270  using bind = Desc<SgAsmDwarfArrayType, SgAsmDwarfConstructList* SgAsmDwarfArrayType::*, &SgAsmDwarfArrayType::p_body>;
2271 };
2273  using node = SgAsmDwarfArrayType;
2274  using base = SgAsmDwarfConstruct;
2275  static constexpr char const * const name{"AsmDwarfArrayType"};
2276  static constexpr unsigned long variant{76};
2277  static constexpr bool concrete{true};
2278  using subclasses_t = mp::List<>;
2280 };
2281 template <> struct node_from_variant_t<76> { using type = SgAsmDwarfArrayType; };
2282 
2283 // Class: AsmDwarfBaseType
2285  using node = SgAsmDwarfBaseType;
2286  using base = SgAsmDwarfConstruct;
2287  static constexpr char const * const name{"AsmDwarfBaseType"};
2288  static constexpr unsigned long variant{77};
2289  static constexpr bool concrete{true};
2290  using subclasses_t = mp::List<>;
2291  using fields_t = mp::List<>;
2292 };
2293 template <> struct node_from_variant_t<77> { using type = SgAsmDwarfBaseType; };
2294 
2295 // Class: AsmDwarfCatchBlock
2297  using node = SgAsmDwarfCatchBlock;
2298  using base = SgAsmDwarfConstruct;
2299  static constexpr char const * const name{"AsmDwarfCatchBlock"};
2300  static constexpr unsigned long variant{78};
2301  static constexpr bool concrete{true};
2302  using subclasses_t = mp::List<>;
2303  using fields_t = mp::List<>;
2304 };
2305 template <> struct node_from_variant_t<78> { using type = SgAsmDwarfCatchBlock; };
2306 
2307 // Class: AsmDwarfClassTemplate
2309  using node = SgAsmDwarfClassTemplate;
2310  using base = SgAsmDwarfConstruct;
2311  static constexpr char const * const name{"AsmDwarfClassTemplate"};
2312  static constexpr unsigned long variant{79};
2313  static constexpr bool concrete{true};
2314  using subclasses_t = mp::List<>;
2315  using fields_t = mp::List<>;
2316 };
2317 template <> struct node_from_variant_t<79> { using type = SgAsmDwarfClassTemplate; };
2318 
2319 // Class: AsmDwarfClassType
2320 template <> struct describe_field_t<SgAsmDwarfClassType,SgAsmDwarfConstructList*,&SgAsmDwarfClassType::p_body> {
2321  using parent = SgAsmDwarfClassType;
2323  static constexpr size_t position{0};
2324  static constexpr char const * const name{"body"};
2325  static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
2326  static constexpr bool traverse{true};
2327  static constexpr auto mbr_ptr{&SgAsmDwarfClassType::p_body};
2328  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2329  using bind = Desc<SgAsmDwarfClassType, SgAsmDwarfConstructList* SgAsmDwarfClassType::*, &SgAsmDwarfClassType::p_body>;
2330 };
2332  using node = SgAsmDwarfClassType;
2333  using base = SgAsmDwarfConstruct;
2334  static constexpr char const * const name{"AsmDwarfClassType"};
2335  static constexpr unsigned long variant{80};
2336  static constexpr bool concrete{true};
2337  using subclasses_t = mp::List<>;
2339 };
2340 template <> struct node_from_variant_t<80> { using type = SgAsmDwarfClassType; };
2341 
2342 // Class: AsmDwarfCommonBlock
2343 template <> struct describe_field_t<SgAsmDwarfCommonBlock,SgAsmDwarfConstructList*,&SgAsmDwarfCommonBlock::p_body> {
2344  using parent = SgAsmDwarfCommonBlock;
2346  static constexpr size_t position{0};
2347  static constexpr char const * const name{"body"};
2348  static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
2349  static constexpr bool traverse{true};
2350  static constexpr auto mbr_ptr{&SgAsmDwarfCommonBlock::p_body};
2351  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2352  using bind = Desc<SgAsmDwarfCommonBlock, SgAsmDwarfConstructList* SgAsmDwarfCommonBlock::*, &SgAsmDwarfCommonBlock::p_body>;
2353 };
2355  using node = SgAsmDwarfCommonBlock;
2356  using base = SgAsmDwarfConstruct;
2357  static constexpr char const * const name{"AsmDwarfCommonBlock"};
2358  static constexpr unsigned long variant{81};
2359  static constexpr bool concrete{true};
2360  using subclasses_t = mp::List<>;
2362 };
2363 template <> struct node_from_variant_t<81> { using type = SgAsmDwarfCommonBlock; };
2364 
2365 // Class: AsmDwarfCommonInclusion
2368  using base = SgAsmDwarfConstruct;
2369  static constexpr char const * const name{"AsmDwarfCommonInclusion"};
2370  static constexpr unsigned long variant{82};
2371  static constexpr bool concrete{true};
2372  using subclasses_t = mp::List<>;
2373  using fields_t = mp::List<>;
2374 };
2375 template <> struct node_from_variant_t<82> { using type = SgAsmDwarfCommonInclusion; };
2376 
2377 // Class: AsmDwarfCompilationUnit
2378 template <> struct describe_field_t<SgAsmDwarfCompilationUnit,std::string,&SgAsmDwarfCompilationUnit::p_producer> {
2380  using field_type = std::string;
2381  static constexpr size_t position{0};
2382  static constexpr char const * const name{"producer"};
2383  static constexpr char const * const typestr{"std::string"};
2384  static constexpr bool traverse{false};
2385  static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnit::p_producer};
2386  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2387  using bind = Desc<SgAsmDwarfCompilationUnit, std::string SgAsmDwarfCompilationUnit::*, &SgAsmDwarfCompilationUnit::p_producer>;
2388 };
2389 template <> struct describe_field_t<SgAsmDwarfCompilationUnit,std::string,&SgAsmDwarfCompilationUnit::p_language> {
2391  using field_type = std::string;
2392  static constexpr size_t position{1};
2393  static constexpr char const * const name{"language"};
2394  static constexpr char const * const typestr{"std::string"};
2395  static constexpr bool traverse{false};
2396  static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnit::p_language};
2397  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2398  using bind = Desc<SgAsmDwarfCompilationUnit, std::string SgAsmDwarfCompilationUnit::*, &SgAsmDwarfCompilationUnit::p_language>;
2399 };
2400 template <> struct describe_field_t<SgAsmDwarfCompilationUnit,uint64_t,&SgAsmDwarfCompilationUnit::p_low_pc> {
2402  using field_type = uint64_t;
2403  static constexpr size_t position{2};
2404  static constexpr char const * const name{"low_pc"};
2405  static constexpr char const * const typestr{"uint64_t"};
2406  static constexpr bool traverse{false};
2407  static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnit::p_low_pc};
2408  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2409  using bind = Desc<SgAsmDwarfCompilationUnit, uint64_t SgAsmDwarfCompilationUnit::*, &SgAsmDwarfCompilationUnit::p_low_pc>;
2410 };
2411 template <> struct describe_field_t<SgAsmDwarfCompilationUnit,uint64_t,&SgAsmDwarfCompilationUnit::p_hi_pc> {
2413  using field_type = uint64_t;
2414  static constexpr size_t position{3};
2415  static constexpr char const * const name{"hi_pc"};
2416  static constexpr char const * const typestr{"uint64_t"};
2417  static constexpr bool traverse{false};
2418  static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnit::p_hi_pc};
2419  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2420  using bind = Desc<SgAsmDwarfCompilationUnit, uint64_t SgAsmDwarfCompilationUnit::*, &SgAsmDwarfCompilationUnit::p_hi_pc>;
2421 };
2422 template <> struct describe_field_t<SgAsmDwarfCompilationUnit,int,&SgAsmDwarfCompilationUnit::p_version_stamp> {
2424  using field_type = int;
2425  static constexpr size_t position{4};
2426  static constexpr char const * const name{"version_stamp"};
2427  static constexpr char const * const typestr{"int"};
2428  static constexpr bool traverse{false};
2429  static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnit::p_version_stamp};
2430  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2431  using bind = Desc<SgAsmDwarfCompilationUnit, int SgAsmDwarfCompilationUnit::*, &SgAsmDwarfCompilationUnit::p_version_stamp>;
2432 };
2433 template <> struct describe_field_t<SgAsmDwarfCompilationUnit,uint64_t,&SgAsmDwarfCompilationUnit::p_abbrev_offset> {
2435  using field_type = uint64_t;
2436  static constexpr size_t position{5};
2437  static constexpr char const * const name{"abbrev_offset"};
2438  static constexpr char const * const typestr{"uint64_t"};
2439  static constexpr bool traverse{false};
2440  static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnit::p_abbrev_offset};
2441  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2442  using bind = Desc<SgAsmDwarfCompilationUnit, uint64_t SgAsmDwarfCompilationUnit::*, &SgAsmDwarfCompilationUnit::p_abbrev_offset>;
2443 };
2444 template <> struct describe_field_t<SgAsmDwarfCompilationUnit,uint64_t,&SgAsmDwarfCompilationUnit::p_address_size> {
2446  using field_type = uint64_t;
2447  static constexpr size_t position{6};
2448  static constexpr char const * const name{"address_size"};
2449  static constexpr char const * const typestr{"uint64_t"};
2450  static constexpr bool traverse{false};
2451  static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnit::p_address_size};
2452  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2453  using bind = Desc<SgAsmDwarfCompilationUnit, uint64_t SgAsmDwarfCompilationUnit::*, &SgAsmDwarfCompilationUnit::p_address_size>;
2454 };
2455 template <> struct describe_field_t<SgAsmDwarfCompilationUnit,uint64_t,&SgAsmDwarfCompilationUnit::p_offset_length> {
2457  using field_type = uint64_t;
2458  static constexpr size_t position{7};
2459  static constexpr char const * const name{"offset_length"};
2460  static constexpr char const * const typestr{"uint64_t"};
2461  static constexpr bool traverse{false};
2462  static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnit::p_offset_length};
2463  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2464  using bind = Desc<SgAsmDwarfCompilationUnit, uint64_t SgAsmDwarfCompilationUnit::*, &SgAsmDwarfCompilationUnit::p_offset_length>;
2465 };
2466 template <> struct describe_field_t<SgAsmDwarfCompilationUnit,SgAsmDwarfLineList*,&SgAsmDwarfCompilationUnit::p_line_info> {
2468  using field_type = SgAsmDwarfLineList*;
2469  static constexpr size_t position{8};
2470  static constexpr char const * const name{"line_info"};
2471  static constexpr char const * const typestr{"SgAsmDwarfLineList*"};
2472  static constexpr bool traverse{true};
2473  static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnit::p_line_info};
2474  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2475  using bind = Desc<SgAsmDwarfCompilationUnit, SgAsmDwarfLineList* SgAsmDwarfCompilationUnit::*, &SgAsmDwarfCompilationUnit::p_line_info>;
2476 };
2477 template <> struct describe_field_t<SgAsmDwarfCompilationUnit,SgAsmDwarfConstructList*,&SgAsmDwarfCompilationUnit::p_language_constructs> {
2480  static constexpr size_t position{9};
2481  static constexpr char const * const name{"language_constructs"};
2482  static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
2483  static constexpr bool traverse{true};
2484  static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnit::p_language_constructs};
2485  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2486  using bind = Desc<SgAsmDwarfCompilationUnit, SgAsmDwarfConstructList* SgAsmDwarfCompilationUnit::*, &SgAsmDwarfCompilationUnit::p_language_constructs>;
2487 };
2488 template <> struct describe_field_t<SgAsmDwarfCompilationUnit,SgAsmDwarfMacroList*,&SgAsmDwarfCompilationUnit::p_macro_info> {
2491  static constexpr size_t position{10};
2492  static constexpr char const * const name{"macro_info"};
2493  static constexpr char const * const typestr{"SgAsmDwarfMacroList*"};
2494  static constexpr bool traverse{true};
2495  static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnit::p_macro_info};
2496  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2497  using bind = Desc<SgAsmDwarfCompilationUnit, SgAsmDwarfMacroList* SgAsmDwarfCompilationUnit::*, &SgAsmDwarfCompilationUnit::p_macro_info>;
2498 };
2501  using base = SgAsmDwarfConstruct;
2502  static constexpr char const * const name{"AsmDwarfCompilationUnit"};
2503  static constexpr unsigned long variant{83};
2504  static constexpr bool concrete{true};
2505  using subclasses_t = mp::List<>;
2507 };
2508 template <> struct node_from_variant_t<83> { using type = SgAsmDwarfCompilationUnit; };
2509 
2510 // Class: AsmDwarfCompilationUnitList
2511 template <> struct describe_field_t<SgAsmDwarfCompilationUnitList,SgAsmDwarfCompilationUnitPtrList,&SgAsmDwarfCompilationUnitList::p_cu_list> {
2513  using field_type = SgAsmDwarfCompilationUnitPtrList;
2514  static constexpr size_t position{0};
2515  static constexpr char const * const name{"cu_list"};
2516  static constexpr char const * const typestr{"SgAsmDwarfCompilationUnitPtrList"};
2517  static constexpr bool traverse{true};
2518  static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnitList::p_cu_list};
2519  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2520  using bind = Desc<SgAsmDwarfCompilationUnitList, SgAsmDwarfCompilationUnitPtrList SgAsmDwarfCompilationUnitList::*, &SgAsmDwarfCompilationUnitList::p_cu_list>;
2521 };
2524  using base = SgAsmDwarfInformation;
2525  static constexpr char const * const name{"AsmDwarfCompilationUnitList"};
2526  static constexpr unsigned long variant{84};
2527  static constexpr bool concrete{true};
2528  using subclasses_t = mp::List<>;
2530 };
2531 template <> struct node_from_variant_t<84> { using type = SgAsmDwarfCompilationUnitList; };
2532 
2533 // Class: AsmDwarfCondition
2535  using node = SgAsmDwarfCondition;
2536  using base = SgAsmDwarfConstruct;
2537  static constexpr char const * const name{"AsmDwarfCondition"};
2538  static constexpr unsigned long variant{85};
2539  static constexpr bool concrete{true};
2540  using subclasses_t = mp::List<>;
2541  using fields_t = mp::List<>;
2542 };
2543 template <> struct node_from_variant_t<85> { using type = SgAsmDwarfCondition; };
2544 
2545 // Class: AsmDwarfConstType
2547  using node = SgAsmDwarfConstType;
2548  using base = SgAsmDwarfConstruct;
2549  static constexpr char const * const name{"AsmDwarfConstType"};
2550  static constexpr unsigned long variant{86};
2551  static constexpr bool concrete{true};
2552  using subclasses_t = mp::List<>;
2553  using fields_t = mp::List<>;
2554 };
2555 template <> struct node_from_variant_t<86> { using type = SgAsmDwarfConstType; };
2556 
2557 // Class: AsmDwarfConstant
2559  using node = SgAsmDwarfConstant;
2560  using base = SgAsmDwarfConstruct;
2561  static constexpr char const * const name{"AsmDwarfConstant"};
2562  static constexpr unsigned long variant{87};
2563  static constexpr bool concrete{true};
2564  using subclasses_t = mp::List<>;
2565  using fields_t = mp::List<>;
2566 };
2567 template <> struct node_from_variant_t<87> { using type = SgAsmDwarfConstant; };
2568 
2569 // Class: AsmDwarfConstruct
2570 template <> struct describe_field_t<SgAsmDwarfConstruct,int,&SgAsmDwarfConstruct::p_nesting_level> {
2571  using parent = SgAsmDwarfConstruct;
2572  using field_type = int;
2573  static constexpr size_t position{0};
2574  static constexpr char const * const name{"nesting_level"};
2575  static constexpr char const * const typestr{"int"};
2576  static constexpr bool traverse{false};
2577  static constexpr auto mbr_ptr{&SgAsmDwarfConstruct::p_nesting_level};
2578  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2579  using bind = Desc<SgAsmDwarfConstruct, int SgAsmDwarfConstruct::*, &SgAsmDwarfConstruct::p_nesting_level>;
2580 };
2581 template <> struct describe_field_t<SgAsmDwarfConstruct,uint64_t,&SgAsmDwarfConstruct::p_offset> {
2582  using parent = SgAsmDwarfConstruct;
2583  using field_type = uint64_t;
2584  static constexpr size_t position{1};
2585  static constexpr char const * const name{"offset"};
2586  static constexpr char const * const typestr{"uint64_t"};
2587  static constexpr bool traverse{false};
2588  static constexpr auto mbr_ptr{&SgAsmDwarfConstruct::p_offset};
2589  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2590  using bind = Desc<SgAsmDwarfConstruct, uint64_t SgAsmDwarfConstruct::*, &SgAsmDwarfConstruct::p_offset>;
2591 };
2592 template <> struct describe_field_t<SgAsmDwarfConstruct,uint64_t,&SgAsmDwarfConstruct::p_overall_offset> {
2593  using parent = SgAsmDwarfConstruct;
2594  using field_type = uint64_t;
2595  static constexpr size_t position{2};
2596  static constexpr char const * const name{"overall_offset"};
2597  static constexpr char const * const typestr{"uint64_t"};
2598  static constexpr bool traverse{false};
2599  static constexpr auto mbr_ptr{&SgAsmDwarfConstruct::p_overall_offset};
2600  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2601  using bind = Desc<SgAsmDwarfConstruct, uint64_t SgAsmDwarfConstruct::*, &SgAsmDwarfConstruct::p_overall_offset>;
2602 };
2603 template <> struct describe_field_t<SgAsmDwarfConstruct,std::string,&SgAsmDwarfConstruct::p_name> {
2604  using parent = SgAsmDwarfConstruct;
2605  using field_type = std::string;
2606  static constexpr size_t position{3};
2607  static constexpr char const * const name{"name"};
2608  static constexpr char const * const typestr{"std::string"};
2609  static constexpr bool traverse{false};
2610  static constexpr auto mbr_ptr{&SgAsmDwarfConstruct::p_name};
2611  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2612  using bind = Desc<SgAsmDwarfConstruct, std::string SgAsmDwarfConstruct::*, &SgAsmDwarfConstruct::p_name>;
2613 };
2614 template <> struct describe_field_t<SgAsmDwarfConstruct,SgAsmDwarfLine*,&SgAsmDwarfConstruct::p_source_position> {
2615  using parent = SgAsmDwarfConstruct;
2616  using field_type = SgAsmDwarfLine*;
2617  static constexpr size_t position{4};
2618  static constexpr char const * const name{"source_position"};
2619  static constexpr char const * const typestr{"SgAsmDwarfLine*"};
2620  static constexpr bool traverse{false};
2621  static constexpr auto mbr_ptr{&SgAsmDwarfConstruct::p_source_position};
2622  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2623  using bind = Desc<SgAsmDwarfConstruct, SgAsmDwarfLine* SgAsmDwarfConstruct::*, &SgAsmDwarfConstruct::p_source_position>;
2624 };
2625 template <> struct describe_field_t<SgAsmDwarfConstruct,AstAttributeMechanism*,&SgAsmDwarfConstruct::p_attributeMechanism> {
2626  using parent = SgAsmDwarfConstruct;
2628  static constexpr size_t position{5};
2629  static constexpr char const * const name{"attributeMechanism"};
2630  static constexpr char const * const typestr{"AstAttributeMechanism*"};
2631  static constexpr bool traverse{false};
2632  static constexpr auto mbr_ptr{&SgAsmDwarfConstruct::p_attributeMechanism};
2633  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2634  using bind = Desc<SgAsmDwarfConstruct, AstAttributeMechanism* SgAsmDwarfConstruct::*, &SgAsmDwarfConstruct::p_attributeMechanism>;
2635 };
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<SgAsmDwarfArrayType, SgAsmDwarfClassType, SgAsmDwarfEntryPoint, SgAsmDwarfEnumerationType, SgAsmDwarfFormalParameter, SgAsmDwarfImportedDeclaration, SgAsmDwarfLabel, SgAsmDwarfLexicalBlock, SgAsmDwarfMember, SgAsmDwarfPointerType, SgAsmDwarfReferenceType, SgAsmDwarfCompilationUnit, SgAsmDwarfStringType, SgAsmDwarfStructureType, SgAsmDwarfSubroutineType, SgAsmDwarfTypedef, SgAsmDwarfUnionType, SgAsmDwarfUnspecifiedParameters, SgAsmDwarfVariant, SgAsmDwarfCommonBlock, SgAsmDwarfCommonInclusion, SgAsmDwarfInheritance, SgAsmDwarfInlinedSubroutine, SgAsmDwarfModule, SgAsmDwarfPtrToMemberType, SgAsmDwarfSetType, SgAsmDwarfSubrangeType, SgAsmDwarfWithStmt, SgAsmDwarfAccessDeclaration, SgAsmDwarfBaseType, SgAsmDwarfCatchBlock, SgAsmDwarfConstType, SgAsmDwarfConstant, SgAsmDwarfEnumerator, SgAsmDwarfFileType, SgAsmDwarfFriend, SgAsmDwarfNamelist, SgAsmDwarfNamelistItem, SgAsmDwarfPackedType, SgAsmDwarfSubprogram, SgAsmDwarfTemplateTypeParameter, SgAsmDwarfTemplateValueParameter, SgAsmDwarfThrownType, SgAsmDwarfTryBlock, SgAsmDwarfVariantPart, SgAsmDwarfVariable, SgAsmDwarfVolatileType, SgAsmDwarfDwarfProcedure, SgAsmDwarfRestrictType, SgAsmDwarfInterfaceType, SgAsmDwarfNamespace, SgAsmDwarfImportedModule, SgAsmDwarfUnspecifiedType, SgAsmDwarfPartialUnit, SgAsmDwarfImportedUnit, SgAsmDwarfMutableType, SgAsmDwarfCondition, SgAsmDwarfSharedType, SgAsmDwarfFormatLabel, SgAsmDwarfFunctionTemplate, SgAsmDwarfClassTemplate, SgAsmDwarfUpcSharedType, SgAsmDwarfUpcStrictType, SgAsmDwarfUpcRelaxedType, SgAsmDwarfUnknownConstruct>;
2644 };
2645 template <> struct node_from_variant_t<88> { using type = SgAsmDwarfConstruct; };
2646 
2647 // Class: AsmDwarfConstructList
2648 template <> struct describe_field_t<SgAsmDwarfConstructList,SgAsmDwarfConstructPtrList,&SgAsmDwarfConstructList::p_list> {
2650  using field_type = SgAsmDwarfConstructPtrList;
2651  static constexpr size_t position{0};
2652  static constexpr char const * const name{"list"};
2653  static constexpr char const * const typestr{"SgAsmDwarfConstructPtrList"};
2654  static constexpr bool traverse{true};
2655  static constexpr auto mbr_ptr{&SgAsmDwarfConstructList::p_list};
2656  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2657  using bind = Desc<SgAsmDwarfConstructList, SgAsmDwarfConstructPtrList SgAsmDwarfConstructList::*, &SgAsmDwarfConstructList::p_list>;
2658 };
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<>;
2667 };
2668 template <> struct node_from_variant_t<89> { using type = SgAsmDwarfConstructList; };
2669 
2670 // Class: AsmDwarfDwarfProcedure
2673  using base = SgAsmDwarfConstruct;
2674  static constexpr char const * const name{"AsmDwarfDwarfProcedure"};
2675  static constexpr unsigned long variant{90};
2676  static constexpr bool concrete{true};
2677  using subclasses_t = mp::List<>;
2678  using fields_t = mp::List<>;
2679 };
2680 template <> struct node_from_variant_t<90> { using type = SgAsmDwarfDwarfProcedure; };
2681 
2682 // Class: AsmDwarfEntryPoint
2684  using node = SgAsmDwarfEntryPoint;
2685  using base = SgAsmDwarfConstruct;
2686  static constexpr char const * const name{"AsmDwarfEntryPoint"};
2687  static constexpr unsigned long variant{91};
2688  static constexpr bool concrete{true};
2689  using subclasses_t = mp::List<>;
2690  using fields_t = mp::List<>;
2691 };
2692 template <> struct node_from_variant_t<91> { using type = SgAsmDwarfEntryPoint; };
2693 
2694 // Class: AsmDwarfEnumerationType
2695 template <> struct describe_field_t<SgAsmDwarfEnumerationType,SgAsmDwarfConstructList*,&SgAsmDwarfEnumerationType::p_body> {
2698  static constexpr size_t position{0};
2699  static constexpr char const * const name{"body"};
2700  static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
2701  static constexpr bool traverse{true};
2702  static constexpr auto mbr_ptr{&SgAsmDwarfEnumerationType::p_body};
2703  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2704  using bind = Desc<SgAsmDwarfEnumerationType, SgAsmDwarfConstructList* SgAsmDwarfEnumerationType::*, &SgAsmDwarfEnumerationType::p_body>;
2705 };
2708  using base = SgAsmDwarfConstruct;
2709  static constexpr char const * const name{"AsmDwarfEnumerationType"};
2710  static constexpr unsigned long variant{92};
2711  static constexpr bool concrete{true};
2712  using subclasses_t = mp::List<>;
2714 };
2715 template <> struct node_from_variant_t<92> { using type = SgAsmDwarfEnumerationType; };
2716 
2717 // Class: AsmDwarfEnumerator
2719  using node = SgAsmDwarfEnumerator;
2720  using base = SgAsmDwarfConstruct;
2721  static constexpr char const * const name{"AsmDwarfEnumerator"};
2722  static constexpr unsigned long variant{93};
2723  static constexpr bool concrete{true};
2724  using subclasses_t = mp::List<>;
2725  using fields_t = mp::List<>;
2726 };
2727 template <> struct node_from_variant_t<93> { using type = SgAsmDwarfEnumerator; };
2728 
2729 // Class: AsmDwarfFileType
2731  using node = SgAsmDwarfFileType;
2732  using base = SgAsmDwarfConstruct;
2733  static constexpr char const * const name{"AsmDwarfFileType"};
2734  static constexpr unsigned long variant{94};
2735  static constexpr bool concrete{true};
2736  using subclasses_t = mp::List<>;
2737  using fields_t = mp::List<>;
2738 };
2739 template <> struct node_from_variant_t<94> { using type = SgAsmDwarfFileType; };
2740 
2741 // Class: AsmDwarfFormalParameter
2744  using base = SgAsmDwarfConstruct;
2745  static constexpr char const * const name{"AsmDwarfFormalParameter"};
2746  static constexpr unsigned long variant{95};
2747  static constexpr bool concrete{true};
2748  using subclasses_t = mp::List<>;
2749  using fields_t = mp::List<>;
2750 };
2751 template <> struct node_from_variant_t<95> { using type = SgAsmDwarfFormalParameter; };
2752 
2753 // Class: AsmDwarfFormatLabel
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 };
2763 template <> struct node_from_variant_t<96> { using type = SgAsmDwarfFormatLabel; };
2764 
2765 // Class: AsmDwarfFriend
2766 template <> 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 };
2775 template <> struct node_from_variant_t<97> { using type = SgAsmDwarfFriend; };
2776 
2777 // Class: AsmDwarfFunctionTemplate
2780  using base = SgAsmDwarfConstruct;
2781  static constexpr char const * const name{"AsmDwarfFunctionTemplate"};
2782  static constexpr unsigned long variant{98};
2783  static constexpr bool concrete{true};
2784  using subclasses_t = mp::List<>;
2785  using fields_t = mp::List<>;
2786 };
2787 template <> struct node_from_variant_t<98> { using type = SgAsmDwarfFunctionTemplate; };
2788 
2789 // Class: AsmDwarfImportedDeclaration
2792  using base = SgAsmDwarfConstruct;
2793  static constexpr char const * const name{"AsmDwarfImportedDeclaration"};
2794  static constexpr unsigned long variant{99};
2795  static constexpr bool concrete{true};
2796  using subclasses_t = mp::List<>;
2797  using fields_t = mp::List<>;
2798 };
2799 template <> struct node_from_variant_t<99> { using type = SgAsmDwarfImportedDeclaration; };
2800 
2801 // Class: AsmDwarfImportedModule
2804  using base = SgAsmDwarfConstruct;
2805  static constexpr char const * const name{"AsmDwarfImportedModule"};
2806  static constexpr unsigned long variant{100};
2807  static constexpr bool concrete{true};
2808  using subclasses_t = mp::List<>;
2809  using fields_t = mp::List<>;
2810 };
2811 template <> struct node_from_variant_t<100> { using type = SgAsmDwarfImportedModule; };
2812 
2813 // Class: AsmDwarfImportedUnit
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 };
2823 template <> struct node_from_variant_t<101> { using type = SgAsmDwarfImportedUnit; };
2824 
2825 // Class: AsmDwarfInformation
2827  using node = SgAsmDwarfInformation;
2829  static constexpr char const * const name{"AsmDwarfInformation"};
2830  static constexpr unsigned long variant{102};
2831  static constexpr bool concrete{false};
2833  using fields_t = mp::List<>;
2834 };
2835 template <> struct node_from_variant_t<102> { using type = SgAsmDwarfInformation; };
2836 
2837 // Class: AsmDwarfInheritance
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 };
2847 template <> struct node_from_variant_t<103> { using type = SgAsmDwarfInheritance; };
2848 
2849 // Class: AsmDwarfInlinedSubroutine
2850 template <> struct describe_field_t<SgAsmDwarfInlinedSubroutine,SgAsmDwarfConstructList*,&SgAsmDwarfInlinedSubroutine::p_body> {
2853  static constexpr size_t position{0};
2854  static constexpr char const * const name{"body"};
2855  static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
2856  static constexpr bool traverse{true};
2857  static constexpr auto mbr_ptr{&SgAsmDwarfInlinedSubroutine::p_body};
2858  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2859  using bind = Desc<SgAsmDwarfInlinedSubroutine, SgAsmDwarfConstructList* SgAsmDwarfInlinedSubroutine::*, &SgAsmDwarfInlinedSubroutine::p_body>;
2860 };
2863  using base = SgAsmDwarfConstruct;
2864  static constexpr char const * const name{"AsmDwarfInlinedSubroutine"};
2865  static constexpr unsigned long variant{104};
2866  static constexpr bool concrete{true};
2867  using subclasses_t = mp::List<>;
2869 };
2870 template <> struct node_from_variant_t<104> { using type = SgAsmDwarfInlinedSubroutine; };
2871 
2872 // Class: AsmDwarfInterfaceType
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 };
2882 template <> struct node_from_variant_t<105> { using type = SgAsmDwarfInterfaceType; };
2883 
2884 // Class: AsmDwarfLabel
2885 template <> 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 };
2894 template <> struct node_from_variant_t<106> { using type = SgAsmDwarfLabel; };
2895 
2896 // Class: AsmDwarfLexicalBlock
2897 template <> struct describe_field_t<SgAsmDwarfLexicalBlock,SgAsmDwarfConstructList*,&SgAsmDwarfLexicalBlock::p_body> {
2900  static constexpr size_t position{0};
2901  static constexpr char const * const name{"body"};
2902  static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
2903  static constexpr bool traverse{true};
2904  static constexpr auto mbr_ptr{&SgAsmDwarfLexicalBlock::p_body};
2905  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2906  using bind = Desc<SgAsmDwarfLexicalBlock, SgAsmDwarfConstructList* SgAsmDwarfLexicalBlock::*, &SgAsmDwarfLexicalBlock::p_body>;
2907 };
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<>;
2916 };
2917 template <> struct node_from_variant_t<107> { using type = SgAsmDwarfLexicalBlock; };
2918 
2919 // Class: AsmDwarfLine
2920 template <> 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 };
2931 template <> 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 };
2942 template <> 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 };
2953 template <> 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 };
2964 template <> 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<>;
2972 };
2973 template <> struct node_from_variant_t<108> { using type = SgAsmDwarfLine; };
2974 
2975 // Class: AsmDwarfLineList
2976 template <> struct describe_field_t<SgAsmDwarfLineList,SgAsmDwarfLinePtrList,&SgAsmDwarfLineList::p_line_list> {
2977  using parent = SgAsmDwarfLineList;
2978  using field_type = SgAsmDwarfLinePtrList;
2979  static constexpr size_t position{0};
2980  static constexpr char const * const name{"line_list"};
2981  static constexpr char const * const typestr{"SgAsmDwarfLinePtrList"};
2982  static constexpr bool traverse{true};
2983  static constexpr auto mbr_ptr{&SgAsmDwarfLineList::p_line_list};
2984  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2985  using bind = Desc<SgAsmDwarfLineList, SgAsmDwarfLinePtrList SgAsmDwarfLineList::*, &SgAsmDwarfLineList::p_line_list>;
2986 };
2988  using node = SgAsmDwarfLineList;
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<>;
2995 };
2996 template <> struct node_from_variant_t<109> { using type = SgAsmDwarfLineList; };
2997 
2998 // Class: AsmDwarfMacro
2999 template <> 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 };
3010 template <> 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<>;
3018 };
3019 template <> struct node_from_variant_t<110> { using type = SgAsmDwarfMacro; };
3020 
3021 // Class: AsmDwarfMacroList
3022 template <> 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 };
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<>;
3041 };
3042 template <> struct node_from_variant_t<111> { using type = SgAsmDwarfMacroList; };
3043 
3044 // Class: AsmDwarfMember
3045 template <> 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 };
3054 template <> struct node_from_variant_t<112> { using type = SgAsmDwarfMember; };
3055 
3056 // Class: AsmDwarfModule
3057 template <> 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 };
3066 template <> struct node_from_variant_t<113> { using type = SgAsmDwarfModule; };
3067 
3068 // Class: AsmDwarfMutableType
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 };
3078 template <> struct node_from_variant_t<114> { using type = SgAsmDwarfMutableType; };
3079 
3080 // Class: AsmDwarfNamelist
3082  using node = SgAsmDwarfNamelist;
3083  using base = SgAsmDwarfConstruct;
3084  static constexpr char const * const name{"AsmDwarfNamelist"};
3085  static constexpr unsigned long variant{115};
3086  static constexpr bool concrete{true};
3087  using subclasses_t = mp::List<>;
3088  using fields_t = mp::List<>;
3089 };
3090 template <> struct node_from_variant_t<115> { using type = SgAsmDwarfNamelist; };
3091 
3092 // Class: AsmDwarfNamelistItem
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 };
3102 template <> struct node_from_variant_t<116> { using type = SgAsmDwarfNamelistItem; };
3103 
3104 // Class: AsmDwarfNamespace
3105 template <> struct describe_field_t<SgAsmDwarfNamespace,SgAsmDwarfConstructList*,&SgAsmDwarfNamespace::p_body> {
3106  using parent = SgAsmDwarfNamespace;
3108  static constexpr size_t position{0};
3109  static constexpr char const * const name{"body"};
3110  static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
3111  static constexpr bool traverse{true};
3112  static constexpr auto mbr_ptr{&SgAsmDwarfNamespace::p_body};
3113  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3114  using bind = Desc<SgAsmDwarfNamespace, SgAsmDwarfConstructList* SgAsmDwarfNamespace::*, &SgAsmDwarfNamespace::p_body>;
3115 };
3117  using node = SgAsmDwarfNamespace;
3118  using base = SgAsmDwarfConstruct;
3119  static constexpr char const * const name{"AsmDwarfNamespace"};
3120  static constexpr unsigned long variant{117};
3121  static constexpr bool concrete{true};
3122  using subclasses_t = mp::List<>;
3124 };
3125 template <> struct node_from_variant_t<117> { using type = SgAsmDwarfNamespace; };
3126 
3127 // Class: AsmDwarfPackedType
3129  using node = SgAsmDwarfPackedType;
3130  using base = SgAsmDwarfConstruct;
3131  static constexpr char const * const name{"AsmDwarfPackedType"};
3132  static constexpr unsigned long variant{118};
3133  static constexpr bool concrete{true};
3134  using subclasses_t = mp::List<>;
3135  using fields_t = mp::List<>;
3136 };
3137 template <> struct node_from_variant_t<118> { using type = SgAsmDwarfPackedType; };
3138 
3139 // Class: AsmDwarfPartialUnit
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 };
3149 template <> struct node_from_variant_t<119> { using type = SgAsmDwarfPartialUnit; };
3150 
3151 // Class: AsmDwarfPointerType
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 };
3161 template <> struct node_from_variant_t<120> { using type = SgAsmDwarfPointerType; };
3162 
3163 // Class: AsmDwarfPtrToMemberType
3166  using base = SgAsmDwarfConstruct;
3167  static constexpr char const * const name{"AsmDwarfPtrToMemberType"};
3168  static constexpr unsigned long variant{121};
3169  static constexpr bool concrete{true};
3170  using subclasses_t = mp::List<>;
3171  using fields_t = mp::List<>;
3172 };
3173 template <> struct node_from_variant_t<121> { using type = SgAsmDwarfPtrToMemberType; };
3174 
3175 // Class: AsmDwarfReferenceType
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 };
3185 template <> struct node_from_variant_t<122> { using type = SgAsmDwarfReferenceType; };
3186 
3187 // Class: AsmDwarfRestrictType
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 };
3197 template <> struct node_from_variant_t<123> { using type = SgAsmDwarfRestrictType; };
3198 
3199 // Class: AsmDwarfSetType
3200 template <> 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 };
3209 template <> struct node_from_variant_t<124> { using type = SgAsmDwarfSetType; };
3210 
3211 // Class: AsmDwarfSharedType
3213  using node = SgAsmDwarfSharedType;
3214  using base = SgAsmDwarfConstruct;
3215  static constexpr char const * const name{"AsmDwarfSharedType"};
3216  static constexpr unsigned long variant{125};
3217  static constexpr bool concrete{true};
3218  using subclasses_t = mp::List<>;
3219  using fields_t = mp::List<>;
3220 };
3221 template <> struct node_from_variant_t<125> { using type = SgAsmDwarfSharedType; };
3222 
3223 // Class: AsmDwarfStringType
3225  using node = SgAsmDwarfStringType;
3226  using base = SgAsmDwarfConstruct;
3227  static constexpr char const * const name{"AsmDwarfStringType"};
3228  static constexpr unsigned long variant{126};
3229  static constexpr bool concrete{true};
3230  using subclasses_t = mp::List<>;
3231  using fields_t = mp::List<>;
3232 };
3233 template <> struct node_from_variant_t<126> { using type = SgAsmDwarfStringType; };
3234 
3235 // Class: AsmDwarfStructureType
3236 template <> struct describe_field_t<SgAsmDwarfStructureType,SgAsmDwarfConstructList*,&SgAsmDwarfStructureType::p_body> {
3239  static constexpr size_t position{0};
3240  static constexpr char const * const name{"body"};
3241  static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
3242  static constexpr bool traverse{true};
3243  static constexpr auto mbr_ptr{&SgAsmDwarfStructureType::p_body};
3244  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3245  using bind = Desc<SgAsmDwarfStructureType, SgAsmDwarfConstructList* SgAsmDwarfStructureType::*, &SgAsmDwarfStructureType::p_body>;
3246 };
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<>;
3255 };
3256 template <> struct node_from_variant_t<127> { using type = SgAsmDwarfStructureType; };
3257 
3258 // Class: AsmDwarfSubprogram
3259 template <> struct describe_field_t<SgAsmDwarfSubprogram,SgAsmDwarfConstructList*,&SgAsmDwarfSubprogram::p_body> {
3260  using parent = SgAsmDwarfSubprogram;
3262  static constexpr size_t position{0};
3263  static constexpr char const * const name{"body"};
3264  static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
3265  static constexpr bool traverse{true};
3266  static constexpr auto mbr_ptr{&SgAsmDwarfSubprogram::p_body};
3267  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3268  using bind = Desc<SgAsmDwarfSubprogram, SgAsmDwarfConstructList* SgAsmDwarfSubprogram::*, &SgAsmDwarfSubprogram::p_body>;
3269 };
3271  using node = SgAsmDwarfSubprogram;
3272  using base = SgAsmDwarfConstruct;
3273  static constexpr char const * const name{"AsmDwarfSubprogram"};
3274  static constexpr unsigned long variant{128};
3275  static constexpr bool concrete{true};
3276  using subclasses_t = mp::List<>;
3278 };
3279 template <> struct node_from_variant_t<128> { using type = SgAsmDwarfSubprogram; };
3280 
3281 // Class: AsmDwarfSubrangeType
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 };
3291 template <> struct node_from_variant_t<129> { using type = SgAsmDwarfSubrangeType; };
3292 
3293 // Class: AsmDwarfSubroutineType
3294 template <> struct describe_field_t<SgAsmDwarfSubroutineType,SgAsmDwarfConstructList*,&SgAsmDwarfSubroutineType::p_body> {
3297  static constexpr size_t position{0};
3298  static constexpr char const * const name{"body"};
3299  static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
3300  static constexpr bool traverse{true};
3301  static constexpr auto mbr_ptr{&SgAsmDwarfSubroutineType::p_body};
3302  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3303  using bind = Desc<SgAsmDwarfSubroutineType, SgAsmDwarfConstructList* SgAsmDwarfSubroutineType::*, &SgAsmDwarfSubroutineType::p_body>;
3304 };
3307  using base = SgAsmDwarfConstruct;
3308  static constexpr char const * const name{"AsmDwarfSubroutineType"};
3309  static constexpr unsigned long variant{130};
3310  static constexpr bool concrete{true};
3311  using subclasses_t = mp::List<>;
3313 };
3314 template <> struct node_from_variant_t<130> { using type = SgAsmDwarfSubroutineType; };
3315 
3316 // Class: AsmDwarfTemplateTypeParameter
3319  using base = SgAsmDwarfConstruct;
3320  static constexpr char const * const name{"AsmDwarfTemplateTypeParameter"};
3321  static constexpr unsigned long variant{131};
3322  static constexpr bool concrete{true};
3323  using subclasses_t = mp::List<>;
3324  using fields_t = mp::List<>;
3325 };
3326 template <> struct node_from_variant_t<131> { using type = SgAsmDwarfTemplateTypeParameter; };
3327 
3328 // Class: AsmDwarfTemplateValueParameter
3331  using base = SgAsmDwarfConstruct;
3332  static constexpr char const * const name{"AsmDwarfTemplateValueParameter"};
3333  static constexpr unsigned long variant{132};
3334  static constexpr bool concrete{true};
3335  using subclasses_t = mp::List<>;
3336  using fields_t = mp::List<>;
3337 };
3338 template <> struct node_from_variant_t<132> { using type = SgAsmDwarfTemplateValueParameter; };
3339 
3340 // Class: AsmDwarfThrownType
3342  using node = SgAsmDwarfThrownType;
3343  using base = SgAsmDwarfConstruct;
3344  static constexpr char const * const name{"AsmDwarfThrownType"};
3345  static constexpr unsigned long variant{133};
3346  static constexpr bool concrete{true};
3347  using subclasses_t = mp::List<>;
3348  using fields_t = mp::List<>;
3349 };
3350 template <> struct node_from_variant_t<133> { using type = SgAsmDwarfThrownType; };
3351 
3352 // Class: AsmDwarfTryBlock
3354  using node = SgAsmDwarfTryBlock;
3355  using base = SgAsmDwarfConstruct;
3356  static constexpr char const * const name{"AsmDwarfTryBlock"};
3357  static constexpr unsigned long variant{134};
3358  static constexpr bool concrete{true};
3359  using subclasses_t = mp::List<>;
3360  using fields_t = mp::List<>;
3361 };
3362 template <> struct node_from_variant_t<134> { using type = SgAsmDwarfTryBlock; };
3363 
3364 // Class: AsmDwarfTypedef
3365 template <> 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 };
3374 template <> struct node_from_variant_t<135> { using type = SgAsmDwarfTypedef; };
3375 
3376 // Class: AsmDwarfUnionType
3377 template <> struct describe_field_t<SgAsmDwarfUnionType,SgAsmDwarfConstructList*,&SgAsmDwarfUnionType::p_body> {
3378  using parent = SgAsmDwarfUnionType;
3380  static constexpr size_t position{0};
3381  static constexpr char const * const name{"body"};
3382  static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
3383  static constexpr bool traverse{true};
3384  static constexpr auto mbr_ptr{&SgAsmDwarfUnionType::p_body};
3385  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3386  using bind = Desc<SgAsmDwarfUnionType, SgAsmDwarfConstructList* SgAsmDwarfUnionType::*, &SgAsmDwarfUnionType::p_body>;
3387 };
3389  using node = SgAsmDwarfUnionType;
3390  using base = SgAsmDwarfConstruct;
3391  static constexpr char const * const name{"AsmDwarfUnionType"};
3392  static constexpr unsigned long variant{136};
3393  static constexpr bool concrete{true};
3394  using subclasses_t = mp::List<>;
3396 };
3397 template <> struct node_from_variant_t<136> { using type = SgAsmDwarfUnionType; };
3398 
3399 // Class: AsmDwarfUnknownConstruct
3402  using base = SgAsmDwarfConstruct;
3403  static constexpr char const * const name{"AsmDwarfUnknownConstruct"};
3404  static constexpr unsigned long variant{137};
3405  static constexpr bool concrete{true};
3406  using subclasses_t = mp::List<>;
3407  using fields_t = mp::List<>;
3408 };
3409 template <> struct node_from_variant_t<137> { using type = SgAsmDwarfUnknownConstruct; };
3410 
3411 // Class: AsmDwarfUnspecifiedParameters
3414  using base = SgAsmDwarfConstruct;
3415  static constexpr char const * const name{"AsmDwarfUnspecifiedParameters"};
3416  static constexpr unsigned long variant{138};
3417  static constexpr bool concrete{true};
3418  using subclasses_t = mp::List<>;
3419  using fields_t = mp::List<>;
3420 };
3421 template <> struct node_from_variant_t<138> { using type = SgAsmDwarfUnspecifiedParameters; };
3422 
3423 // Class: AsmDwarfUnspecifiedType
3426  using base = SgAsmDwarfConstruct;
3427  static constexpr char const * const name{"AsmDwarfUnspecifiedType"};
3428  static constexpr unsigned long variant{139};
3429  static constexpr bool concrete{true};
3430  using subclasses_t = mp::List<>;
3431  using fields_t = mp::List<>;
3432 };
3433 template <> struct node_from_variant_t<139> { using type = SgAsmDwarfUnspecifiedType; };
3434 
3435 // Class: AsmDwarfUpcRelaxedType
3438  using base = SgAsmDwarfConstruct;
3439  static constexpr char const * const name{"AsmDwarfUpcRelaxedType"};
3440  static constexpr unsigned long variant{140};
3441  static constexpr bool concrete{true};
3442  using subclasses_t = mp::List<>;
3443  using fields_t = mp::List<>;
3444 };
3445 template <> struct node_from_variant_t<140> { using type = SgAsmDwarfUpcRelaxedType; };
3446 
3447 // Class: AsmDwarfUpcSharedType
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 };
3457 template <> struct node_from_variant_t<141> { using type = SgAsmDwarfUpcSharedType; };
3458 
3459 // Class: AsmDwarfUpcStrictType
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 };
3469 template <> struct node_from_variant_t<142> { using type = SgAsmDwarfUpcStrictType; };
3470 
3471 // Class: AsmDwarfVariable
3473  using node = SgAsmDwarfVariable;
3474  using base = SgAsmDwarfConstruct;
3475  static constexpr char const * const name{"AsmDwarfVariable"};
3476  static constexpr unsigned long variant{143};
3477  static constexpr bool concrete{true};
3478  using subclasses_t = mp::List<>;
3479  using fields_t = mp::List<>;
3480 };
3481 template <> struct node_from_variant_t<143> { using type = SgAsmDwarfVariable; };
3482 
3483 // Class: AsmDwarfVariant
3484 template <> 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 };
3493 template <> struct node_from_variant_t<144> { using type = SgAsmDwarfVariant; };
3494 
3495 // Class: AsmDwarfVariantPart
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 };
3505 template <> struct node_from_variant_t<145> { using type = SgAsmDwarfVariantPart; };
3506 
3507 // Class: AsmDwarfVolatileType
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 };
3517 template <> struct node_from_variant_t<146> { using type = SgAsmDwarfVolatileType; };
3518 
3519 // Class: AsmDwarfWithStmt
3521  using node = SgAsmDwarfWithStmt;
3522  using base = SgAsmDwarfConstruct;
3523  static constexpr char const * const name{"AsmDwarfWithStmt"};
3524  static constexpr unsigned long variant{147};
3525  static constexpr bool concrete{true};
3526  using subclasses_t = mp::List<>;
3527  using fields_t = mp::List<>;
3528 };
3529 template <> struct node_from_variant_t<147> { using type = SgAsmDwarfWithStmt; };
3530 
3531 // Class: AsmElfDynamicEntry
3532 template <> 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 };
3543 template <> struct describe_field_t<SgAsmElfDynamicEntry,rose_rva_t,&SgAsmElfDynamicEntry::p_d_val> {
3544  using parent = SgAsmElfDynamicEntry;
3545  using field_type = rose_rva_t;
3546  static constexpr size_t position{1};
3547  static constexpr char const * const name{"d_val"};
3548  static constexpr char const * const typestr{"rose_rva_t"};
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_rva_t SgAsmElfDynamicEntry::*, &SgAsmElfDynamicEntry::p_d_val>;
3553 };
3554 template <> 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 };
3565 template <> 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 };
3577  using node = SgAsmElfDynamicEntry;
3579  static constexpr char const * const name{"AsmElfDynamicEntry"};
3580  static constexpr unsigned long variant{148};
3581  static constexpr bool concrete{true};
3582  using subclasses_t = mp::List<>;
3584 };
3585 template <> struct node_from_variant_t<148> { using type = SgAsmElfDynamicEntry; };
3586 
3587 // Class: AsmElfDynamicEntryList
3588 template <> struct describe_field_t<SgAsmElfDynamicEntryList,SgAsmElfDynamicEntryPtrList,&SgAsmElfDynamicEntryList::p_entries> {
3590  using field_type = SgAsmElfDynamicEntryPtrList;
3591  static constexpr size_t position{0};
3592  static constexpr char const * const name{"entries"};
3593  static constexpr char const * const typestr{"SgAsmElfDynamicEntryPtrList"};
3594  static constexpr bool traverse{false};
3595  static constexpr auto mbr_ptr{&SgAsmElfDynamicEntryList::p_entries};
3596  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3597  using bind = Desc<SgAsmElfDynamicEntryList, SgAsmElfDynamicEntryPtrList SgAsmElfDynamicEntryList::*, &SgAsmElfDynamicEntryList::p_entries>;
3598 };
3602  static constexpr char const * const name{"AsmElfDynamicEntryList"};
3603  static constexpr unsigned long variant{149};
3604  static constexpr bool concrete{true};
3605  using subclasses_t = mp::List<>;
3607 };
3608 template <> struct node_from_variant_t<149> { using type = SgAsmElfDynamicEntryList; };
3609 
3610 // Class: AsmElfDynamicSection
3611 template <> struct describe_field_t<SgAsmElfDynamicSection,SgAsmElfDynamicEntryList*,&SgAsmElfDynamicSection::p_entries> {
3614  static constexpr size_t position{0};
3615  static constexpr char const * const name{"entries"};
3616  static constexpr char const * const typestr{"SgAsmElfDynamicEntryList*"};
3617  static constexpr bool traverse{true};
3618  static constexpr auto mbr_ptr{&SgAsmElfDynamicSection::p_entries};
3619  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3620  using bind = Desc<SgAsmElfDynamicSection, SgAsmElfDynamicEntryList* SgAsmElfDynamicSection::*, &SgAsmElfDynamicSection::p_entries>;
3621 };
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<>;
3630 };
3631 template <> struct node_from_variant_t<150> { using type = SgAsmElfDynamicSection; };
3632 
3633 // Class: AsmElfEHFrameEntryCI
3634 template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,int,&SgAsmElfEHFrameEntryCI::p_version> {
3636  using field_type = int;
3637  static constexpr size_t position{0};
3638  static constexpr char const * const name{"version"};
3639  static constexpr char const * const typestr{"int"};
3640  static constexpr bool traverse{false};
3641  static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_version};
3642  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3643  using bind = Desc<SgAsmElfEHFrameEntryCI, int SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_version>;
3644 };
3645 template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,std::string,&SgAsmElfEHFrameEntryCI::p_augmentation_string> {
3647  using field_type = std::string;
3648  static constexpr size_t position{1};
3649  static constexpr char const * const name{"augmentation_string"};
3650  static constexpr char const * const typestr{"std::string"};
3651  static constexpr bool traverse{false};
3652  static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_augmentation_string};
3653  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3654  using bind = Desc<SgAsmElfEHFrameEntryCI, std::string SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_augmentation_string>;
3655 };
3656 template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,uint64_t,&SgAsmElfEHFrameEntryCI::p_eh_data> {
3658  using field_type = uint64_t;
3659  static constexpr size_t position{2};
3660  static constexpr char const * const name{"eh_data"};
3661  static constexpr char const * const typestr{"uint64_t"};
3662  static constexpr bool traverse{false};
3663  static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_eh_data};
3664  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3665  using bind = Desc<SgAsmElfEHFrameEntryCI, uint64_t SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_eh_data>;
3666 };
3667 template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,uint64_t,&SgAsmElfEHFrameEntryCI::p_code_alignment_factor> {
3669  using field_type = uint64_t;
3670  static constexpr size_t position{3};
3671  static constexpr char const * const name{"code_alignment_factor"};
3672  static constexpr char const * const typestr{"uint64_t"};
3673  static constexpr bool traverse{false};
3674  static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_code_alignment_factor};
3675  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3676  using bind = Desc<SgAsmElfEHFrameEntryCI, uint64_t SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_code_alignment_factor>;
3677 };
3678 template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,int64_t,&SgAsmElfEHFrameEntryCI::p_data_alignment_factor> {
3680  using field_type = int64_t;
3681  static constexpr size_t position{4};
3682  static constexpr char const * const name{"data_alignment_factor"};
3683  static constexpr char const * const typestr{"int64_t"};
3684  static constexpr bool traverse{false};
3685  static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_data_alignment_factor};
3686  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3687  using bind = Desc<SgAsmElfEHFrameEntryCI, int64_t SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_data_alignment_factor>;
3688 };
3689 template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,uint64_t,&SgAsmElfEHFrameEntryCI::p_augmentation_data_length> {
3691  using field_type = uint64_t;
3692  static constexpr size_t position{5};
3693  static constexpr char const * const name{"augmentation_data_length"};
3694  static constexpr char const * const typestr{"uint64_t"};
3695  static constexpr bool traverse{false};
3696  static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_augmentation_data_length};
3697  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3698  using bind = Desc<SgAsmElfEHFrameEntryCI, uint64_t SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_augmentation_data_length>;
3699 };
3700 template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,int,&SgAsmElfEHFrameEntryCI::p_lsda_encoding> {
3702  using field_type = int;
3703  static constexpr size_t position{6};
3704  static constexpr char const * const name{"lsda_encoding"};
3705  static constexpr char const * const typestr{"int"};
3706  static constexpr bool traverse{false};
3707  static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_lsda_encoding};
3708  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3709  using bind = Desc<SgAsmElfEHFrameEntryCI, int SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_lsda_encoding>;
3710 };
3711 template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,int,&SgAsmElfEHFrameEntryCI::p_prh_encoding> {
3713  using field_type = int;
3714  static constexpr size_t position{7};
3715  static constexpr char const * const name{"prh_encoding"};
3716  static constexpr char const * const typestr{"int"};
3717  static constexpr bool traverse{false};
3718  static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_prh_encoding};
3719  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3720  using bind = Desc<SgAsmElfEHFrameEntryCI, int SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_prh_encoding>;
3721 };
3722 template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,unsigned,&SgAsmElfEHFrameEntryCI::p_prh_arg> {
3724  using field_type = unsigned;
3725  static constexpr size_t position{8};
3726  static constexpr char const * const name{"prh_arg"};
3727  static constexpr char const * const typestr{"unsigned"};
3728  static constexpr bool traverse{false};
3729  static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_prh_arg};
3730  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3731  using bind = Desc<SgAsmElfEHFrameEntryCI, unsigned SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_prh_arg>;
3732 };
3733 template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,rose_addr_t,&SgAsmElfEHFrameEntryCI::p_prh_addr> {
3735  using field_type = rose_addr_t;
3736  static constexpr size_t position{9};
3737  static constexpr char const * const name{"prh_addr"};
3738  static constexpr char const * const typestr{"rose_addr_t"};
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_addr_t SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_prh_addr>;
3743 };
3744 template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,int,&SgAsmElfEHFrameEntryCI::p_addr_encoding> {
3746  using field_type = int;
3747  static constexpr size_t position{10};
3748  static constexpr char const * const name{"addr_encoding"};
3749  static constexpr char const * const typestr{"int"};
3750  static constexpr bool traverse{false};
3751  static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_addr_encoding};
3752  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3753  using bind = Desc<SgAsmElfEHFrameEntryCI, int SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_addr_encoding>;
3754 };
3755 template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,bool,&SgAsmElfEHFrameEntryCI::p_sig_frame> {
3757  using field_type = bool;
3758  static constexpr size_t position{11};
3759  static constexpr char const * const name{"sig_frame"};
3760  static constexpr char const * const typestr{"bool"};
3761  static constexpr bool traverse{false};
3762  static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_sig_frame};
3763  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3764  using bind = Desc<SgAsmElfEHFrameEntryCI, bool SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_sig_frame>;
3765 };
3766 template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,SgUnsignedCharList,&SgAsmElfEHFrameEntryCI::p_instructions> {
3768  using field_type = SgUnsignedCharList;
3769  static constexpr size_t position{12};
3770  static constexpr char const * const name{"instructions"};
3771  static constexpr char const * const typestr{"SgUnsignedCharList"};
3772  static constexpr bool traverse{false};
3773  static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_instructions};
3774  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3775  using bind = Desc<SgAsmElfEHFrameEntryCI, SgUnsignedCharList SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_instructions>;
3776 };
3777 template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,SgAsmElfEHFrameEntryFDList*,&SgAsmElfEHFrameEntryCI::p_fd_entries> {
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 };
3789  using node = SgAsmElfEHFrameEntryCI;
3791  static constexpr char const * const name{"AsmElfEHFrameEntryCI"};
3792  static constexpr unsigned long variant{151};
3793  static constexpr bool concrete{true};
3794  using subclasses_t = mp::List<>;
3796 };
3797 template <> struct node_from_variant_t<151> { using type = SgAsmElfEHFrameEntryCI; };
3798 
3799 // Class: AsmElfEHFrameEntryCIList
3800 template <> struct describe_field_t<SgAsmElfEHFrameEntryCIList,SgAsmElfEHFrameEntryCIPtrList,&SgAsmElfEHFrameEntryCIList::p_entries> {
3802  using field_type = SgAsmElfEHFrameEntryCIPtrList;
3803  static constexpr size_t position{0};
3804  static constexpr char const * const name{"entries"};
3805  static constexpr char const * const typestr{"SgAsmElfEHFrameEntryCIPtrList"};
3806  static constexpr bool traverse{false};
3807  static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCIList::p_entries};
3808  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3809  using bind = Desc<SgAsmElfEHFrameEntryCIList, SgAsmElfEHFrameEntryCIPtrList SgAsmElfEHFrameEntryCIList::*, &SgAsmElfEHFrameEntryCIList::p_entries>;
3810 };
3814  static constexpr char const * const name{"AsmElfEHFrameEntryCIList"};
3815  static constexpr unsigned long variant{152};
3816  static constexpr bool concrete{true};
3817  using subclasses_t =