ROSE  0.11.109.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,SgDeclarationStatement*,&SgAdaTaskBodyDecl::p_specificationDeclaration> {
721  using parent = SgAdaTaskBodyDecl;
723  static constexpr size_t position{1};
724  static constexpr char const * const name{"specificationDeclaration"};
725  static constexpr char const * const typestr{"SgDeclarationStatement*"};
726  static constexpr bool traverse{false};
727  static constexpr auto mbr_ptr{&SgAdaTaskBodyDecl::p_specificationDeclaration};
728  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
729  using bind = Desc<SgAdaTaskBodyDecl, SgDeclarationStatement* SgAdaTaskBodyDecl::*, &SgAdaTaskBodyDecl::p_specificationDeclaration>;
730 };
731 template <> struct describe_field_t<SgAdaTaskBodyDecl,SgAdaTaskBody*,&SgAdaTaskBodyDecl::p_definition> {
732  using parent = SgAdaTaskBodyDecl;
733  using field_type = SgAdaTaskBody*;
734  static constexpr size_t position{2};
735  static constexpr char const * const name{"definition"};
736  static constexpr char const * const typestr{"SgAdaTaskBody*"};
737  static constexpr bool traverse{true};
738  static constexpr auto mbr_ptr{&SgAdaTaskBodyDecl::p_definition};
739  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
740  using bind = Desc<SgAdaTaskBodyDecl, SgAdaTaskBody* SgAdaTaskBodyDecl::*, &SgAdaTaskBodyDecl::p_definition>;
741 };
742 template <> struct describe_node_t<SgAdaTaskBodyDecl> {
743  using node = SgAdaTaskBodyDecl;
745  static constexpr char const * const name{"AdaTaskBodyDecl"};
746  static constexpr unsigned long variant{21};
747  static constexpr bool concrete{true};
748  using subclasses_t = mp::List<>;
750 };
751 template <> struct node_from_variant_t<21> { using type = SgAdaTaskBodyDecl; };
752 
753 // Class: AdaTaskSpec
754 template <> struct describe_field_t<SgAdaTaskSpec,SgAdaTaskBody*,&SgAdaTaskSpec::p_body> {
755  using parent = SgAdaTaskSpec;
756  using field_type = SgAdaTaskBody*;
757  static constexpr size_t position{0};
758  static constexpr char const * const name{"body"};
759  static constexpr char const * const typestr{"SgAdaTaskBody*"};
760  static constexpr bool traverse{false};
761  static constexpr auto mbr_ptr{&SgAdaTaskSpec::p_body};
762  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
763  using bind = Desc<SgAdaTaskSpec, SgAdaTaskBody* SgAdaTaskSpec::*, &SgAdaTaskSpec::p_body>;
764 };
765 template <> struct describe_field_t<SgAdaTaskSpec,bool,&SgAdaTaskSpec::p_hasMembers> {
766  using parent = SgAdaTaskSpec;
767  using field_type = bool;
768  static constexpr size_t position{1};
769  static constexpr char const * const name{"hasMembers"};
770  static constexpr char const * const typestr{"bool"};
771  static constexpr bool traverse{false};
772  static constexpr auto mbr_ptr{&SgAdaTaskSpec::p_hasMembers};
773  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
774  using bind = Desc<SgAdaTaskSpec, bool SgAdaTaskSpec::*, &SgAdaTaskSpec::p_hasMembers>;
775 };
776 template <> struct describe_field_t<SgAdaTaskSpec,SgDeclarationStatementPtrList,&SgAdaTaskSpec::p_declarations> {
777  using parent = SgAdaTaskSpec;
778  using field_type = SgDeclarationStatementPtrList;
779  static constexpr size_t position{2};
780  static constexpr char const * const name{"declarations"};
781  static constexpr char const * const typestr{"SgDeclarationStatementPtrList"};
782  static constexpr bool traverse{true};
783  static constexpr auto mbr_ptr{&SgAdaTaskSpec::p_declarations};
784  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
785  using bind = Desc<SgAdaTaskSpec, SgDeclarationStatementPtrList SgAdaTaskSpec::*, &SgAdaTaskSpec::p_declarations>;
786 };
787 template <> struct describe_field_t<SgAdaTaskSpec,bool,&SgAdaTaskSpec::p_hasPrivate> {
788  using parent = SgAdaTaskSpec;
789  using field_type = bool;
790  static constexpr size_t position{3};
791  static constexpr char const * const name{"hasPrivate"};
792  static constexpr char const * const typestr{"bool"};
793  static constexpr bool traverse{false};
794  static constexpr auto mbr_ptr{&SgAdaTaskSpec::p_hasPrivate};
795  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
796  using bind = Desc<SgAdaTaskSpec, bool SgAdaTaskSpec::*, &SgAdaTaskSpec::p_hasPrivate>;
797 };
798 template <> struct describe_node_t<SgAdaTaskSpec> {
799  using node = SgAdaTaskSpec;
800  using base = SgScopeStatement;
801  static constexpr char const * const name{"AdaTaskSpec"};
802  static constexpr unsigned long variant{22};
803  static constexpr bool concrete{true};
804  using subclasses_t = mp::List<>;
806 };
807 template <> struct node_from_variant_t<22> { using type = SgAdaTaskSpec; };
808 
809 // Class: AdaTaskSpecDecl
810 template <> struct describe_field_t<SgAdaTaskSpecDecl,SgName,&SgAdaTaskSpecDecl::p_name> {
811  using parent = SgAdaTaskSpecDecl;
812  using field_type = SgName;
813  static constexpr size_t position{0};
814  static constexpr char const * const name{"name"};
815  static constexpr char const * const typestr{"SgName"};
816  static constexpr bool traverse{false};
817  static constexpr auto mbr_ptr{&SgAdaTaskSpecDecl::p_name};
818  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
819  using bind = Desc<SgAdaTaskSpecDecl, SgName SgAdaTaskSpecDecl::*, &SgAdaTaskSpecDecl::p_name>;
820 };
821 template <> struct describe_field_t<SgAdaTaskSpecDecl,SgAdaTaskSpec*,&SgAdaTaskSpecDecl::p_definition> {
822  using parent = SgAdaTaskSpecDecl;
823  using field_type = SgAdaTaskSpec*;
824  static constexpr size_t position{1};
825  static constexpr char const * const name{"definition"};
826  static constexpr char const * const typestr{"SgAdaTaskSpec*"};
827  static constexpr bool traverse{true};
828  static constexpr auto mbr_ptr{&SgAdaTaskSpecDecl::p_definition};
829  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
830  using bind = Desc<SgAdaTaskSpecDecl, SgAdaTaskSpec* SgAdaTaskSpecDecl::*, &SgAdaTaskSpecDecl::p_definition>;
831 };
832 template <> struct describe_field_t<SgAdaTaskSpecDecl,SgAdaTaskType*,&SgAdaTaskSpecDecl::p_type> {
833  using parent = SgAdaTaskSpecDecl;
834  using field_type = SgAdaTaskType*;
835  static constexpr size_t position{2};
836  static constexpr char const * const name{"type"};
837  static constexpr char const * const typestr{"SgAdaTaskType*"};
838  static constexpr bool traverse{false};
839  static constexpr auto mbr_ptr{&SgAdaTaskSpecDecl::p_type};
840  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
841  using bind = Desc<SgAdaTaskSpecDecl, SgAdaTaskType* SgAdaTaskSpecDecl::*, &SgAdaTaskSpecDecl::p_type>;
842 };
843 template <> struct describe_node_t<SgAdaTaskSpecDecl> {
844  using node = SgAdaTaskSpecDecl;
846  static constexpr char const * const name{"AdaTaskSpecDecl"};
847  static constexpr unsigned long variant{23};
848  static constexpr bool concrete{true};
849  using subclasses_t = mp::List<>;
851 };
852 template <> struct node_from_variant_t<23> { using type = SgAdaTaskSpecDecl; };
853 
854 // Class: AdaTaskSymbol
855 template <> struct describe_field_t<SgAdaTaskSymbol,SgDeclarationStatement*,&SgAdaTaskSymbol::p_declaration> {
856  using parent = SgAdaTaskSymbol;
858  static constexpr size_t position{0};
859  static constexpr char const * const name{"declaration"};
860  static constexpr char const * const typestr{"SgDeclarationStatement*"};
861  static constexpr bool traverse{true};
862  static constexpr auto mbr_ptr{&SgAdaTaskSymbol::p_declaration};
863  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
864  using bind = Desc<SgAdaTaskSymbol, SgDeclarationStatement* SgAdaTaskSymbol::*, &SgAdaTaskSymbol::p_declaration>;
865 };
866 template <> struct describe_node_t<SgAdaTaskSymbol> {
867  using node = SgAdaTaskSymbol;
868  using base = SgSymbol;
869  static constexpr char const * const name{"AdaTaskSymbol"};
870  static constexpr unsigned long variant{24};
871  static constexpr bool concrete{true};
872  using subclasses_t = mp::List<>;
874 };
875 template <> struct node_from_variant_t<24> { using type = SgAdaTaskSymbol; };
876 
877 // Class: AdaTaskRefExp
878 template <> struct describe_field_t<SgAdaTaskRefExp,SgAdaTaskSpecDecl*,&SgAdaTaskRefExp::p_decl> {
879  using parent = SgAdaTaskRefExp;
880  using field_type = SgAdaTaskSpecDecl*;
881  static constexpr size_t position{0};
882  static constexpr char const * const name{"decl"};
883  static constexpr char const * const typestr{"SgAdaTaskSpecDecl*"};
884  static constexpr bool traverse{false};
885  static constexpr auto mbr_ptr{&SgAdaTaskRefExp::p_decl};
886  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
887  using bind = Desc<SgAdaTaskRefExp, SgAdaTaskSpecDecl* SgAdaTaskRefExp::*, &SgAdaTaskRefExp::p_decl>;
888 };
889 template <> struct describe_node_t<SgAdaTaskRefExp> {
890  using node = SgAdaTaskRefExp;
891  using base = SgExpression;
892  static constexpr char const * const name{"AdaTaskRefExp"};
893  static constexpr unsigned long variant{25};
894  static constexpr bool concrete{true};
895  using subclasses_t = mp::List<>;
897 };
898 template <> struct node_from_variant_t<25> { using type = SgAdaTaskRefExp; };
899 
900 // Class: AdaTaskType
901 template <> struct describe_node_t<SgAdaTaskType> {
902  using node = SgAdaTaskType;
903  using base = SgNamedType;
904  static constexpr char const * const name{"AdaTaskType"};
905  static constexpr unsigned long variant{26};
906  static constexpr bool concrete{true};
907  using subclasses_t = mp::List<>;
908  using fields_t = mp::List<>;
909 };
910 template <> struct node_from_variant_t<26> { using type = SgAdaTaskType; };
911 
912 // Class: AdaTaskTypeDecl
913 template <> struct describe_field_t<SgAdaTaskTypeDecl,SgName,&SgAdaTaskTypeDecl::p_name> {
914  using parent = SgAdaTaskTypeDecl;
915  using field_type = SgName;
916  static constexpr size_t position{0};
917  static constexpr char const * const name{"name"};
918  static constexpr char const * const typestr{"SgName"};
919  static constexpr bool traverse{false};
920  static constexpr auto mbr_ptr{&SgAdaTaskTypeDecl::p_name};
921  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
922  using bind = Desc<SgAdaTaskTypeDecl, SgName SgAdaTaskTypeDecl::*, &SgAdaTaskTypeDecl::p_name>;
923 };
924 template <> struct describe_field_t<SgAdaTaskTypeDecl,SgAdaTaskSpec*,&SgAdaTaskTypeDecl::p_definition> {
925  using parent = SgAdaTaskTypeDecl;
926  using field_type = SgAdaTaskSpec*;
927  static constexpr size_t position{1};
928  static constexpr char const * const name{"definition"};
929  static constexpr char const * const typestr{"SgAdaTaskSpec*"};
930  static constexpr bool traverse{true};
931  static constexpr auto mbr_ptr{&SgAdaTaskTypeDecl::p_definition};
932  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
933  using bind = Desc<SgAdaTaskTypeDecl, SgAdaTaskSpec* SgAdaTaskTypeDecl::*, &SgAdaTaskTypeDecl::p_definition>;
934 };
935 template <> struct describe_field_t<SgAdaTaskTypeDecl,SgAdaTaskType*,&SgAdaTaskTypeDecl::p_type> {
936  using parent = SgAdaTaskTypeDecl;
937  using field_type = SgAdaTaskType*;
938  static constexpr size_t position{2};
939  static constexpr char const * const name{"type"};
940  static constexpr char const * const typestr{"SgAdaTaskType*"};
941  static constexpr bool traverse{false};
942  static constexpr auto mbr_ptr{&SgAdaTaskTypeDecl::p_type};
943  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
944  using bind = Desc<SgAdaTaskTypeDecl, SgAdaTaskType* SgAdaTaskTypeDecl::*, &SgAdaTaskTypeDecl::p_type>;
945 };
946 template <> struct describe_node_t<SgAdaTaskTypeDecl> {
947  using node = SgAdaTaskTypeDecl;
949  static constexpr char const * const name{"AdaTaskTypeDecl"};
950  static constexpr unsigned long variant{27};
951  static constexpr bool concrete{true};
952  using subclasses_t = mp::List<>;
954 };
955 template <> struct node_from_variant_t<27> { using type = SgAdaTaskTypeDecl; };
956 
957 // Class: AdaTypeConstraint
959  using node = SgAdaTypeConstraint;
960  using base = SgLocatedNodeSupport;
961  static constexpr char const * const name{"AdaTypeConstraint"};
962  static constexpr unsigned long variant{28};
963  static constexpr bool concrete{false};
965  using fields_t = mp::List<>;
966 };
967 template <> struct node_from_variant_t<28> { using type = SgAdaTypeConstraint; };
968 
969 // Class: AddOp
970 template <> struct describe_node_t<SgAddOp> {
971  using node = SgAddOp;
972  using base = SgBinaryOp;
973  static constexpr char const * const name{"AddOp"};
974  static constexpr unsigned long variant{29};
975  static constexpr bool concrete{true};
976  using subclasses_t = mp::List<>;
977  using fields_t = mp::List<>;
978 };
979 template <> struct node_from_variant_t<29> { using type = SgAddOp; };
980 
981 // Class: AddressOfOp
982 template <> struct describe_field_t<SgAddressOfOp,SgExpression*,&SgAddressOfOp::p_originalExpressionTree> {
983  using parent = SgAddressOfOp;
984  using field_type = SgExpression*;
985  static constexpr size_t position{0};
986  static constexpr char const * const name{"originalExpressionTree"};
987  static constexpr char const * const typestr{"SgExpression*"};
988  static constexpr bool traverse{false};
989  static constexpr auto mbr_ptr{&SgAddressOfOp::p_originalExpressionTree};
990  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
991  using bind = Desc<SgAddressOfOp, SgExpression* SgAddressOfOp::*, &SgAddressOfOp::p_originalExpressionTree>;
992 };
993 template <> struct describe_node_t<SgAddressOfOp> {
994  using node = SgAddressOfOp;
995  using base = SgUnaryOp;
996  static constexpr char const * const name{"AddressOfOp"};
997  static constexpr unsigned long variant{30};
998  static constexpr bool concrete{true};
999  using subclasses_t = mp::List<>;
1001 };
1002 template <> struct node_from_variant_t<30> { using type = SgAddressOfOp; };
1003 
1004 // Class: AggregateInitializer
1007  using field_type = SgExprListExp*;
1008  static constexpr size_t position{0};
1009  static constexpr char const * const name{"initializers"};
1010  static constexpr char const * const typestr{"SgExprListExp*"};
1011  static constexpr bool traverse{true};
1012  static constexpr auto mbr_ptr{&SgAggregateInitializer::p_initializers};
1013  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1014  using bind = Desc<SgAggregateInitializer, SgExprListExp* SgAggregateInitializer::*, &SgAggregateInitializer::p_initializers>;
1015 };
1016 template <> struct describe_field_t<SgAggregateInitializer,SgType*,&SgAggregateInitializer::p_expression_type> {
1018  using field_type = SgType*;
1019  static constexpr size_t position{1};
1020  static constexpr char const * const name{"expression_type"};
1021  static constexpr char const * const typestr{"SgType*"};
1022  static constexpr bool traverse{false};
1023  static constexpr auto mbr_ptr{&SgAggregateInitializer::p_expression_type};
1024  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1025  using bind = Desc<SgAggregateInitializer, SgType* SgAggregateInitializer::*, &SgAggregateInitializer::p_expression_type>;
1026 };
1027 template <> struct describe_field_t<SgAggregateInitializer,bool,&SgAggregateInitializer::p_need_explicit_braces> {
1029  using field_type = bool;
1030  static constexpr size_t position{2};
1031  static constexpr char const * const name{"need_explicit_braces"};
1032  static constexpr char const * const typestr{"bool"};
1033  static constexpr bool traverse{false};
1034  static constexpr auto mbr_ptr{&SgAggregateInitializer::p_need_explicit_braces};
1035  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1036  using bind = Desc<SgAggregateInitializer, bool SgAggregateInitializer::*, &SgAggregateInitializer::p_need_explicit_braces>;
1037 };
1038 template <> struct describe_field_t<SgAggregateInitializer,bool,&SgAggregateInitializer::p_uses_compound_literal> {
1040  using field_type = bool;
1041  static constexpr size_t position{3};
1042  static constexpr char const * const name{"uses_compound_literal"};
1043  static constexpr char const * const typestr{"bool"};
1044  static constexpr bool traverse{false};
1045  static constexpr auto mbr_ptr{&SgAggregateInitializer::p_uses_compound_literal};
1046  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1047  using bind = Desc<SgAggregateInitializer, bool SgAggregateInitializer::*, &SgAggregateInitializer::p_uses_compound_literal>;
1048 };
1049 template <> struct describe_field_t<SgAggregateInitializer,bool,&SgAggregateInitializer::p_requiresGlobalNameQualificationOnType> {
1051  using field_type = bool;
1052  static constexpr size_t position{4};
1053  static constexpr char const * const name{"requiresGlobalNameQualificationOnType"};
1054  static constexpr char const * const typestr{"bool"};
1055  static constexpr bool traverse{false};
1056  static constexpr auto mbr_ptr{&SgAggregateInitializer::p_requiresGlobalNameQualificationOnType};
1057  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1058  using bind = Desc<SgAggregateInitializer, bool SgAggregateInitializer::*, &SgAggregateInitializer::p_requiresGlobalNameQualificationOnType>;
1059 };
1060 template <> struct describe_field_t<SgAggregateInitializer,int,&SgAggregateInitializer::p_name_qualification_length_for_type> {
1062  using field_type = int;
1063  static constexpr size_t position{5};
1064  static constexpr char const * const name{"name_qualification_length_for_type"};
1065  static constexpr char const * const typestr{"int"};
1066  static constexpr bool traverse{false};
1067  static constexpr auto mbr_ptr{&SgAggregateInitializer::p_name_qualification_length_for_type};
1068  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1069  using bind = Desc<SgAggregateInitializer, int SgAggregateInitializer::*, &SgAggregateInitializer::p_name_qualification_length_for_type>;
1070 };
1071 template <> struct describe_field_t<SgAggregateInitializer,bool,&SgAggregateInitializer::p_type_elaboration_required_for_type> {
1073  using field_type = bool;
1074  static constexpr size_t position{6};
1075  static constexpr char const * const name{"type_elaboration_required_for_type"};
1076  static constexpr char const * const typestr{"bool"};
1077  static constexpr bool traverse{false};
1078  static constexpr auto mbr_ptr{&SgAggregateInitializer::p_type_elaboration_required_for_type};
1079  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1080  using bind = Desc<SgAggregateInitializer, bool SgAggregateInitializer::*, &SgAggregateInitializer::p_type_elaboration_required_for_type>;
1081 };
1082 template <> struct describe_field_t<SgAggregateInitializer,bool,&SgAggregateInitializer::p_global_qualification_required_for_type> {
1084  using field_type = bool;
1085  static constexpr size_t position{7};
1086  static constexpr char const * const name{"global_qualification_required_for_type"};
1087  static constexpr char const * const typestr{"bool"};
1088  static constexpr bool traverse{false};
1089  static constexpr auto mbr_ptr{&SgAggregateInitializer::p_global_qualification_required_for_type};
1090  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1091  using bind = Desc<SgAggregateInitializer, bool SgAggregateInitializer::*, &SgAggregateInitializer::p_global_qualification_required_for_type>;
1092 };
1093 template <> struct describe_field_t<SgAggregateInitializer,SgExpression*,&SgAggregateInitializer::p_originalExpressionTree> {
1095  using field_type = SgExpression*;
1096  static constexpr size_t position{8};
1097  static constexpr char const * const name{"originalExpressionTree"};
1098  static constexpr char const * const typestr{"SgExpression*"};
1099  static constexpr bool traverse{false};
1100  static constexpr auto mbr_ptr{&SgAggregateInitializer::p_originalExpressionTree};
1101  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1102  using bind = Desc<SgAggregateInitializer, SgExpression* SgAggregateInitializer::*, &SgAggregateInitializer::p_originalExpressionTree>;
1103 };
1105  using node = SgAggregateInitializer;
1106  using base = SgInitializer;
1107  static constexpr char const * const name{"AggregateInitializer"};
1108  static constexpr unsigned long variant{31};
1109  static constexpr bool concrete{true};
1110  using subclasses_t = mp::List<>;
1112 };
1113 template <> struct node_from_variant_t<31> { using type = SgAggregateInitializer; };
1114 
1115 // Class: AliasSymbol
1116 template <> struct describe_field_t<SgAliasSymbol,SgSymbol*,&SgAliasSymbol::p_alias> {
1117  using parent = SgAliasSymbol;
1118  using field_type = SgSymbol*;
1119  static constexpr size_t position{0};
1120  static constexpr char const * const name{"alias"};
1121  static constexpr char const * const typestr{"SgSymbol*"};
1122  static constexpr bool traverse{true};
1123  static constexpr auto mbr_ptr{&SgAliasSymbol::p_alias};
1124  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1125  using bind = Desc<SgAliasSymbol, SgSymbol* SgAliasSymbol::*, &SgAliasSymbol::p_alias>;
1126 };
1127 template <> struct describe_field_t<SgAliasSymbol,bool,&SgAliasSymbol::p_isRenamed> {
1128  using parent = SgAliasSymbol;
1129  using field_type = bool;
1130  static constexpr size_t position{1};
1131  static constexpr char const * const name{"isRenamed"};
1132  static constexpr char const * const typestr{"bool"};
1133  static constexpr bool traverse{false};
1134  static constexpr auto mbr_ptr{&SgAliasSymbol::p_isRenamed};
1135  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1136  using bind = Desc<SgAliasSymbol, bool SgAliasSymbol::*, &SgAliasSymbol::p_isRenamed>;
1137 };
1138 template <> struct describe_field_t<SgAliasSymbol,SgName,&SgAliasSymbol::p_new_name> {
1139  using parent = SgAliasSymbol;
1140  using field_type = SgName;
1141  static constexpr size_t position{2};
1142  static constexpr char const * const name{"new_name"};
1143  static constexpr char const * const typestr{"SgName"};
1144  static constexpr bool traverse{false};
1145  static constexpr auto mbr_ptr{&SgAliasSymbol::p_new_name};
1146  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1147  using bind = Desc<SgAliasSymbol, SgName SgAliasSymbol::*, &SgAliasSymbol::p_new_name>;
1148 };
1149 template <> struct describe_field_t<SgAliasSymbol,SgNodePtrList,&SgAliasSymbol::p_causal_nodes> {
1150  using parent = SgAliasSymbol;
1151  using field_type = SgNodePtrList;
1152  static constexpr size_t position{3};
1153  static constexpr char const * const name{"causal_nodes"};
1154  static constexpr char const * const typestr{"SgNodePtrList"};
1155  static constexpr bool traverse{false};
1156  static constexpr auto mbr_ptr{&SgAliasSymbol::p_causal_nodes};
1157  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1158  using bind = Desc<SgAliasSymbol, SgNodePtrList SgAliasSymbol::*, &SgAliasSymbol::p_causal_nodes>;
1159 };
1160 template <> struct describe_node_t<SgAliasSymbol> {
1161  using node = SgAliasSymbol;
1162  using base = SgSymbol;
1163  static constexpr char const * const name{"AliasSymbol"};
1164  static constexpr unsigned long variant{32};
1165  static constexpr bool concrete{true};
1166  using subclasses_t = mp::List<>;
1168 };
1169 template <> struct node_from_variant_t<32> { using type = SgAliasSymbol; };
1170 
1171 // Class: AllocateStatement
1172 template <> struct describe_field_t<SgAllocateStatement,SgExprListExp*,&SgAllocateStatement::p_expr_list> {
1173  using parent = SgAllocateStatement;
1174  using field_type = SgExprListExp*;
1175  static constexpr size_t position{0};
1176  static constexpr char const * const name{"expr_list"};
1177  static constexpr char const * const typestr{"SgExprListExp*"};
1178  static constexpr bool traverse{true};
1179  static constexpr auto mbr_ptr{&SgAllocateStatement::p_expr_list};
1180  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1181  using bind = Desc<SgAllocateStatement, SgExprListExp* SgAllocateStatement::*, &SgAllocateStatement::p_expr_list>;
1182 };
1183 template <> struct describe_field_t<SgAllocateStatement,SgExpression*,&SgAllocateStatement::p_stat_expression> {
1184  using parent = SgAllocateStatement;
1185  using field_type = SgExpression*;
1186  static constexpr size_t position{1};
1187  static constexpr char const * const name{"stat_expression"};
1188  static constexpr char const * const typestr{"SgExpression*"};
1189  static constexpr bool traverse{true};
1190  static constexpr auto mbr_ptr{&SgAllocateStatement::p_stat_expression};
1191  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1192  using bind = Desc<SgAllocateStatement, SgExpression* SgAllocateStatement::*, &SgAllocateStatement::p_stat_expression>;
1193 };
1194 template <> struct describe_field_t<SgAllocateStatement,SgExpression*,&SgAllocateStatement::p_errmsg_expression> {
1195  using parent = SgAllocateStatement;
1196  using field_type = SgExpression*;
1197  static constexpr size_t position{2};
1198  static constexpr char const * const name{"errmsg_expression"};
1199  static constexpr char const * const typestr{"SgExpression*"};
1200  static constexpr bool traverse{true};
1201  static constexpr auto mbr_ptr{&SgAllocateStatement::p_errmsg_expression};
1202  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1203  using bind = Desc<SgAllocateStatement, SgExpression* SgAllocateStatement::*, &SgAllocateStatement::p_errmsg_expression>;
1204 };
1205 template <> struct describe_field_t<SgAllocateStatement,SgExpression*,&SgAllocateStatement::p_source_expression> {
1206  using parent = SgAllocateStatement;
1207  using field_type = SgExpression*;
1208  static constexpr size_t position{3};
1209  static constexpr char const * const name{"source_expression"};
1210  static constexpr char const * const typestr{"SgExpression*"};
1211  static constexpr bool traverse{true};
1212  static constexpr auto mbr_ptr{&SgAllocateStatement::p_source_expression};
1213  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1214  using bind = Desc<SgAllocateStatement, SgExpression* SgAllocateStatement::*, &SgAllocateStatement::p_source_expression>;
1215 };
1217  using node = SgAllocateStatement;
1218  using base = SgStatement;
1219  static constexpr char const * const name{"AllocateStatement"};
1220  static constexpr unsigned long variant{33};
1221  static constexpr bool concrete{true};
1222  using subclasses_t = mp::List<>;
1224 };
1225 template <> struct node_from_variant_t<33> { using type = SgAllocateStatement; };
1226 
1227 // Class: AndAssignOp
1228 template <> struct describe_node_t<SgAndAssignOp> {
1229  using node = SgAndAssignOp;
1230  using base = SgCompoundAssignOp;
1231  static constexpr char const * const name{"AndAssignOp"};
1232  static constexpr unsigned long variant{34};
1233  static constexpr bool concrete{true};
1234  using subclasses_t = mp::List<>;
1235  using fields_t = mp::List<>;
1236 };
1237 template <> struct node_from_variant_t<34> { using type = SgAndAssignOp; };
1238 
1239 // Class: AndOp
1240 template <> struct describe_node_t<SgAndOp> {
1241  using node = SgAndOp;
1242  using base = SgBinaryOp;
1243  static constexpr char const * const name{"AndOp"};
1244  static constexpr unsigned long variant{35};
1245  static constexpr bool concrete{true};
1246  using subclasses_t = mp::List<>;
1247  using fields_t = mp::List<>;
1248 };
1249 template <> struct node_from_variant_t<35> { using type = SgAndOp; };
1250 
1251 // Class: ArithmeticIfStatement
1252 template <> struct describe_field_t<SgArithmeticIfStatement,SgExpression*,&SgArithmeticIfStatement::p_conditional> {
1254  using field_type = SgExpression*;
1255  static constexpr size_t position{0};
1256  static constexpr char const * const name{"conditional"};
1257  static constexpr char const * const typestr{"SgExpression*"};
1258  static constexpr bool traverse{true};
1259  static constexpr auto mbr_ptr{&SgArithmeticIfStatement::p_conditional};
1260  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1261  using bind = Desc<SgArithmeticIfStatement, SgExpression* SgArithmeticIfStatement::*, &SgArithmeticIfStatement::p_conditional>;
1262 };
1263 template <> struct describe_field_t<SgArithmeticIfStatement,SgLabelRefExp*,&SgArithmeticIfStatement::p_less_label> {
1265  using field_type = SgLabelRefExp*;
1266  static constexpr size_t position{1};
1267  static constexpr char const * const name{"less_label"};
1268  static constexpr char const * const typestr{"SgLabelRefExp*"};
1269  static constexpr bool traverse{false};
1270  static constexpr auto mbr_ptr{&SgArithmeticIfStatement::p_less_label};
1271  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1272  using bind = Desc<SgArithmeticIfStatement, SgLabelRefExp* SgArithmeticIfStatement::*, &SgArithmeticIfStatement::p_less_label>;
1273 };
1274 template <> struct describe_field_t<SgArithmeticIfStatement,SgLabelRefExp*,&SgArithmeticIfStatement::p_equal_label> {
1276  using field_type = SgLabelRefExp*;
1277  static constexpr size_t position{2};
1278  static constexpr char const * const name{"equal_label"};
1279  static constexpr char const * const typestr{"SgLabelRefExp*"};
1280  static constexpr bool traverse{false};
1281  static constexpr auto mbr_ptr{&SgArithmeticIfStatement::p_equal_label};
1282  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1283  using bind = Desc<SgArithmeticIfStatement, SgLabelRefExp* SgArithmeticIfStatement::*, &SgArithmeticIfStatement::p_equal_label>;
1284 };
1285 template <> struct describe_field_t<SgArithmeticIfStatement,SgLabelRefExp*,&SgArithmeticIfStatement::p_greater_label> {
1287  using field_type = SgLabelRefExp*;
1288  static constexpr size_t position{3};
1289  static constexpr char const * const name{"greater_label"};
1290  static constexpr char const * const typestr{"SgLabelRefExp*"};
1291  static constexpr bool traverse{false};
1292  static constexpr auto mbr_ptr{&SgArithmeticIfStatement::p_greater_label};
1293  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1294  using bind = Desc<SgArithmeticIfStatement, SgLabelRefExp* SgArithmeticIfStatement::*, &SgArithmeticIfStatement::p_greater_label>;
1295 };
1297  using node = SgArithmeticIfStatement;
1298  using base = SgStatement;
1299  static constexpr char const * const name{"ArithmeticIfStatement"};
1300  static constexpr unsigned long variant{36};
1301  static constexpr bool concrete{true};
1302  using subclasses_t = mp::List<>;
1304 };
1305 template <> struct node_from_variant_t<36> { using type = SgArithmeticIfStatement; };
1306 
1307 // Class: ArrayType
1308 template <> struct describe_field_t<SgArrayType,SgType*,&SgArrayType::p_base_type> {
1309  using parent = SgArrayType;
1310  using field_type = SgType*;
1311  static constexpr size_t position{0};
1312  static constexpr char const * const name{"base_type"};
1313  static constexpr char const * const typestr{"SgType*"};
1314  static constexpr bool traverse{false};
1315  static constexpr auto mbr_ptr{&SgArrayType::p_base_type};
1316  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1317  using bind = Desc<SgArrayType, SgType* SgArrayType::*, &SgArrayType::p_base_type>;
1318 };
1319 template <> struct describe_field_t<SgArrayType,SgExpression*,&SgArrayType::p_index> {
1320  using parent = SgArrayType;
1321  using field_type = SgExpression*;
1322  static constexpr size_t position{1};
1323  static constexpr char const * const name{"index"};
1324  static constexpr char const * const typestr{"SgExpression*"};
1325  static constexpr bool traverse{true};
1326  static constexpr auto mbr_ptr{&SgArrayType::p_index};
1327  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1328  using bind = Desc<SgArrayType, SgExpression* SgArrayType::*, &SgArrayType::p_index>;
1329 };
1330 template <> struct describe_field_t<SgArrayType,SgExprListExp*,&SgArrayType::p_dim_info> {
1331  using parent = SgArrayType;
1332  using field_type = SgExprListExp*;
1333  static constexpr size_t position{2};
1334  static constexpr char const * const name{"dim_info"};
1335  static constexpr char const * const typestr{"SgExprListExp*"};
1336  static constexpr bool traverse{true};
1337  static constexpr auto mbr_ptr{&SgArrayType::p_dim_info};
1338  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1339  using bind = Desc<SgArrayType, SgExprListExp* SgArrayType::*, &SgArrayType::p_dim_info>;
1340 };
1341 template <> struct describe_field_t<SgArrayType,int,&SgArrayType::p_rank> {
1342  using parent = SgArrayType;
1343  using field_type = int;
1344  static constexpr size_t position{3};
1345  static constexpr char const * const name{"rank"};
1346  static constexpr char const * const typestr{"int"};
1347  static constexpr bool traverse{false};
1348  static constexpr auto mbr_ptr{&SgArrayType::p_rank};
1349  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1350  using bind = Desc<SgArrayType, int SgArrayType::*, &SgArrayType::p_rank>;
1351 };
1352 template <> struct describe_field_t<SgArrayType,int,&SgArrayType::p_number_of_elements> {
1353  using parent = SgArrayType;
1354  using field_type = int;
1355  static constexpr size_t position{4};
1356  static constexpr char const * const name{"number_of_elements"};
1357  static constexpr char const * const typestr{"int"};
1358  static constexpr bool traverse{false};
1359  static constexpr auto mbr_ptr{&SgArrayType::p_number_of_elements};
1360  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1361  using bind = Desc<SgArrayType, int SgArrayType::*, &SgArrayType::p_number_of_elements>;
1362 };
1363 template <> struct describe_field_t<SgArrayType,bool,&SgArrayType::p_is_variable_length_array> {
1364  using parent = SgArrayType;
1365  using field_type = bool;
1366  static constexpr size_t position{5};
1367  static constexpr char const * const name{"is_variable_length_array"};
1368  static constexpr char const * const typestr{"bool"};
1369  static constexpr bool traverse{false};
1370  static constexpr auto mbr_ptr{&SgArrayType::p_is_variable_length_array};
1371  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1372  using bind = Desc<SgArrayType, bool SgArrayType::*, &SgArrayType::p_is_variable_length_array>;
1373 };
1374 template <> struct describe_node_t<SgArrayType> {
1375  using node = SgArrayType;
1376  using base = SgType;
1377  static constexpr char const * const name{"ArrayType"};
1378  static constexpr unsigned long variant{37};
1379  static constexpr bool concrete{true};
1380  using subclasses_t = mp::List<>;
1382 };
1383 template <> struct node_from_variant_t<37> { using type = SgArrayType; };
1384 
1385 // Class: ArrowExp
1386 template <> struct describe_node_t<SgArrowExp> {
1387  using node = SgArrowExp;
1388  using base = SgBinaryOp;
1389  static constexpr char const * const name{"ArrowExp"};
1390  static constexpr unsigned long variant{38};
1391  static constexpr bool concrete{true};
1392  using subclasses_t = mp::List<>;
1393  using fields_t = mp::List<>;
1394 };
1395 template <> struct node_from_variant_t<38> { using type = SgArrowExp; };
1396 
1397 // Class: ArrowStarOp
1398 template <> struct describe_node_t<SgArrowStarOp> {
1399  using node = SgArrowStarOp;
1400  using base = SgBinaryOp;
1401  static constexpr char const * const name{"ArrowStarOp"};
1402  static constexpr unsigned long variant{39};
1403  static constexpr bool concrete{true};
1404  using subclasses_t = mp::List<>;
1405  using fields_t = mp::List<>;
1406 };
1407 template <> struct node_from_variant_t<39> { using type = SgArrowStarOp; };
1408 
1409 // Class: AsmBasicString
1410 template <> struct describe_field_t<SgAsmBasicString,std::string,&SgAsmBasicString::p_string> {
1411  using parent = SgAsmBasicString;
1412  using field_type = std::string;
1413  static constexpr size_t position{0};
1414  static constexpr char const * const name{"string"};
1415  static constexpr char const * const typestr{"std::string"};
1416  static constexpr bool traverse{false};
1417  static constexpr auto mbr_ptr{&SgAsmBasicString::p_string};
1418  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1419  using bind = Desc<SgAsmBasicString, std::string SgAsmBasicString::*, &SgAsmBasicString::p_string>;
1420 };
1421 template <> struct describe_node_t<SgAsmBasicString> {
1422  using node = SgAsmBasicString;
1423  using base = SgAsmGenericString;
1424  static constexpr char const * const name{"AsmBasicString"};
1425  static constexpr unsigned long variant{46};
1426  static constexpr bool concrete{true};
1427  using subclasses_t = mp::List<>;
1429 };
1430 template <> struct node_from_variant_t<46> { using type = SgAsmBasicString; };
1431 
1432 // Class: AsmBinaryAdd
1433 template <> struct describe_node_t<SgAsmBinaryAdd> {
1434  using node = SgAsmBinaryAdd;
1435  using base = SgAsmBinaryExpression;
1436  static constexpr char const * const name{"AsmBinaryAdd"};
1437  static constexpr unsigned long variant{47};
1438  static constexpr bool concrete{true};
1439  using subclasses_t = mp::List<>;
1440  using fields_t = mp::List<>;
1441 };
1442 template <> struct node_from_variant_t<47> { using type = SgAsmBinaryAdd; };
1443 
1444 // Class: AsmBinaryAsr
1445 template <> struct describe_node_t<SgAsmBinaryAsr> {
1446  using node = SgAsmBinaryAsr;
1447  using base = SgAsmBinaryExpression;
1448  static constexpr char const * const name{"AsmBinaryAsr"};
1449  static constexpr unsigned long variant{50};
1450  static constexpr bool concrete{true};
1451  using subclasses_t = mp::List<>;
1452  using fields_t = mp::List<>;
1453 };
1454 template <> struct node_from_variant_t<50> { using type = SgAsmBinaryAsr; };
1455 
1456 // Class: AsmBinaryDivide
1457 template <> struct describe_node_t<SgAsmBinaryDivide> {
1458  using node = SgAsmBinaryDivide;
1459  using base = SgAsmBinaryExpression;
1460  static constexpr char const * const name{"AsmBinaryDivide"};
1461  static constexpr unsigned long variant{51};
1462  static constexpr bool concrete{true};
1463  using subclasses_t = mp::List<>;
1464  using fields_t = mp::List<>;
1465 };
1466 template <> struct node_from_variant_t<51> { using type = SgAsmBinaryDivide; };
1467 
1468 // Class: AsmBinaryExpression
1469 template <> struct describe_field_t<SgAsmBinaryExpression,SgAsmExpression*,&SgAsmBinaryExpression::p_lhs> {
1470  using parent = SgAsmBinaryExpression;
1471  using field_type = SgAsmExpression*;
1472  static constexpr size_t position{0};
1473  static constexpr char const * const name{"lhs"};
1474  static constexpr char const * const typestr{"SgAsmExpression*"};
1475  static constexpr bool traverse{true};
1476  static constexpr auto mbr_ptr{&SgAsmBinaryExpression::p_lhs};
1477  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1478  using bind = Desc<SgAsmBinaryExpression, SgAsmExpression* SgAsmBinaryExpression::*, &SgAsmBinaryExpression::p_lhs>;
1479 };
1480 template <> struct describe_field_t<SgAsmBinaryExpression,SgAsmExpression*,&SgAsmBinaryExpression::p_rhs> {
1481  using parent = SgAsmBinaryExpression;
1482  using field_type = SgAsmExpression*;
1483  static constexpr size_t position{1};
1484  static constexpr char const * const name{"rhs"};
1485  static constexpr char const * const typestr{"SgAsmExpression*"};
1486  static constexpr bool traverse{true};
1487  static constexpr auto mbr_ptr{&SgAsmBinaryExpression::p_rhs};
1488  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1489  using bind = Desc<SgAsmBinaryExpression, SgAsmExpression* SgAsmBinaryExpression::*, &SgAsmBinaryExpression::p_rhs>;
1490 };
1492  using node = SgAsmBinaryExpression;
1493  using base = SgAsmExpression;
1494  static constexpr char const * const name{"AsmBinaryExpression"};
1495  static constexpr unsigned long variant{52};
1496  static constexpr bool concrete{false};
1499 };
1500 template <> struct node_from_variant_t<52> { using type = SgAsmBinaryExpression; };
1501 
1502 // Class: AsmBinaryLsl
1503 template <> struct describe_node_t<SgAsmBinaryLsl> {
1504  using node = SgAsmBinaryLsl;
1505  using base = SgAsmBinaryExpression;
1506  static constexpr char const * const name{"AsmBinaryLsl"};
1507  static constexpr unsigned long variant{53};
1508  static constexpr bool concrete{true};
1509  using subclasses_t = mp::List<>;
1510  using fields_t = mp::List<>;
1511 };
1512 template <> struct node_from_variant_t<53> { using type = SgAsmBinaryLsl; };
1513 
1514 // Class: AsmBinaryLsr
1515 template <> struct describe_node_t<SgAsmBinaryLsr> {
1516  using node = SgAsmBinaryLsr;
1517  using base = SgAsmBinaryExpression;
1518  static constexpr char const * const name{"AsmBinaryLsr"};
1519  static constexpr unsigned long variant{54};
1520  static constexpr bool concrete{true};
1521  using subclasses_t = mp::List<>;
1522  using fields_t = mp::List<>;
1523 };
1524 template <> struct node_from_variant_t<54> { using type = SgAsmBinaryLsr; };
1525 
1526 // Class: AsmBinaryMod
1527 template <> struct describe_node_t<SgAsmBinaryMod> {
1528  using node = SgAsmBinaryMod;
1529  using base = SgAsmBinaryExpression;
1530  static constexpr char const * const name{"AsmBinaryMod"};
1531  static constexpr unsigned long variant{55};
1532  static constexpr bool concrete{true};
1533  using subclasses_t = mp::List<>;
1534  using fields_t = mp::List<>;
1535 };
1536 template <> struct node_from_variant_t<55> { using type = SgAsmBinaryMod; };
1537 
1538 // Class: AsmBinaryMsl
1539 template <> struct describe_node_t<SgAsmBinaryMsl> {
1540  using node = SgAsmBinaryMsl;
1541  using base = SgAsmBinaryExpression;
1542  static constexpr char const * const name{"AsmBinaryMsl"};
1543  static constexpr unsigned long variant{56};
1544  static constexpr bool concrete{true};
1545  using subclasses_t = mp::List<>;
1546  using fields_t = mp::List<>;
1547 };
1548 template <> struct node_from_variant_t<56> { using type = SgAsmBinaryMsl; };
1549 
1550 // Class: AsmBinaryMultiply
1552  using node = SgAsmBinaryMultiply;
1553  using base = SgAsmBinaryExpression;
1554  static constexpr char const * const name{"AsmBinaryMultiply"};
1555  static constexpr unsigned long variant{57};
1556  static constexpr bool concrete{true};
1557  using subclasses_t = mp::List<>;
1558  using fields_t = mp::List<>;
1559 };
1560 template <> struct node_from_variant_t<57> { using type = SgAsmBinaryMultiply; };
1561 
1562 // Class: AsmBinaryRor
1563 template <> struct describe_node_t<SgAsmBinaryRor> {
1564  using node = SgAsmBinaryRor;
1565  using base = SgAsmBinaryExpression;
1566  static constexpr char const * const name{"AsmBinaryRor"};
1567  static constexpr unsigned long variant{58};
1568  static constexpr bool concrete{true};
1569  using subclasses_t = mp::List<>;
1570  using fields_t = mp::List<>;
1571 };
1572 template <> struct node_from_variant_t<58> { using type = SgAsmBinaryRor; };
1573 
1574 // Class: AsmBinarySubtract
1576  using node = SgAsmBinarySubtract;
1577  using base = SgAsmBinaryExpression;
1578  static constexpr char const * const name{"AsmBinarySubtract"};
1579  static constexpr unsigned long variant{59};
1580  static constexpr bool concrete{true};
1581  using subclasses_t = mp::List<>;
1582  using fields_t = mp::List<>;
1583 };
1584 template <> struct node_from_variant_t<59> { using type = SgAsmBinarySubtract; };
1585 
1586 // Class: AsmBlock
1587 template <> struct describe_field_t<SgAsmBlock,rose_addr_t,&SgAsmBlock::p_id> {
1588  using parent = SgAsmBlock;
1589  using field_type = rose_addr_t;
1590  static constexpr size_t position{0};
1591  static constexpr char const * const name{"id"};
1592  static constexpr char const * const typestr{"rose_addr_t"};
1593  static constexpr bool traverse{false};
1594  static constexpr auto mbr_ptr{&SgAsmBlock::p_id};
1595  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1596  using bind = Desc<SgAsmBlock, rose_addr_t SgAsmBlock::*, &SgAsmBlock::p_id>;
1597 };
1598 template <> struct describe_field_t<SgAsmBlock,unsigned,&SgAsmBlock::p_reason> {
1599  using parent = SgAsmBlock;
1600  using field_type = unsigned;
1601  static constexpr size_t position{1};
1602  static constexpr char const * const name{"reason"};
1603  static constexpr char const * const typestr{"unsigned"};
1604  static constexpr bool traverse{false};
1605  static constexpr auto mbr_ptr{&SgAsmBlock::p_reason};
1606  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1607  using bind = Desc<SgAsmBlock, unsigned SgAsmBlock::*, &SgAsmBlock::p_reason>;
1608 };
1609 template <> struct describe_field_t<SgAsmBlock,SgAsmStatementPtrList,&SgAsmBlock::p_statementList> {
1610  using parent = SgAsmBlock;
1611  using field_type = SgAsmStatementPtrList;
1612  static constexpr size_t position{2};
1613  static constexpr char const * const name{"statementList"};
1614  static constexpr char const * const typestr{"SgAsmStatementPtrList"};
1615  static constexpr bool traverse{true};
1616  static constexpr auto mbr_ptr{&SgAsmBlock::p_statementList};
1617  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1618  using bind = Desc<SgAsmBlock, SgAsmStatementPtrList SgAsmBlock::*, &SgAsmBlock::p_statementList>;
1619 };
1620 template <> struct describe_field_t<SgAsmBlock,SgAsmIntegerValuePtrList,&SgAsmBlock::p_successors> {
1621  using parent = SgAsmBlock;
1622  using field_type = SgAsmIntegerValuePtrList;
1623  static constexpr size_t position{3};
1624  static constexpr char const * const name{"successors"};
1625  static constexpr char const * const typestr{"SgAsmIntegerValuePtrList"};
1626  static constexpr bool traverse{false};
1627  static constexpr auto mbr_ptr{&SgAsmBlock::p_successors};
1628  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1629  using bind = Desc<SgAsmBlock, SgAsmIntegerValuePtrList SgAsmBlock::*, &SgAsmBlock::p_successors>;
1630 };
1631 template <> struct describe_field_t<SgAsmBlock,bool,&SgAsmBlock::p_successors_complete> {
1632  using parent = SgAsmBlock;
1633  using field_type = bool;
1634  static constexpr size_t position{4};
1635  static constexpr char const * const name{"successors_complete"};
1636  static constexpr char const * const typestr{"bool"};
1637  static constexpr bool traverse{false};
1638  static constexpr auto mbr_ptr{&SgAsmBlock::p_successors_complete};
1639  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1640  using bind = Desc<SgAsmBlock, bool SgAsmBlock::*, &SgAsmBlock::p_successors_complete>;
1641 };
1642 template <> struct describe_field_t<SgAsmBlock,SgAsmBlock*,&SgAsmBlock::p_immediate_dominator> {
1643  using parent = SgAsmBlock;
1644  using field_type = SgAsmBlock*;
1645  static constexpr size_t position{5};
1646  static constexpr char const * const name{"immediate_dominator"};
1647  static constexpr char const * const typestr{"SgAsmBlock*"};
1648  static constexpr bool traverse{false};
1649  static constexpr auto mbr_ptr{&SgAsmBlock::p_immediate_dominator};
1650  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1651  using bind = Desc<SgAsmBlock, SgAsmBlock* SgAsmBlock::*, &SgAsmBlock::p_immediate_dominator>;
1652 };
1653 template <> struct describe_field_t<SgAsmBlock,size_t,&SgAsmBlock::p_cached_vertex> {
1654  using parent = SgAsmBlock;
1655  using field_type = size_t;
1656  static constexpr size_t position{6};
1657  static constexpr char const * const name{"cached_vertex"};
1658  static constexpr char const * const typestr{"size_t"};
1659  static constexpr bool traverse{false};
1660  static constexpr auto mbr_ptr{&SgAsmBlock::p_cached_vertex};
1661  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1662  using bind = Desc<SgAsmBlock, size_t SgAsmBlock::*, &SgAsmBlock::p_cached_vertex>;
1663 };
1664 template <> struct describe_field_t<SgAsmBlock,double,&SgAsmBlock::p_code_likelihood> {
1665  using parent = SgAsmBlock;
1666  using field_type = double;
1667  static constexpr size_t position{7};
1668  static constexpr char const * const name{"code_likelihood"};
1669  static constexpr char const * const typestr{"double"};
1670  static constexpr bool traverse{false};
1671  static constexpr auto mbr_ptr{&SgAsmBlock::p_code_likelihood};
1672  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1673  using bind = Desc<SgAsmBlock, double SgAsmBlock::*, &SgAsmBlock::p_code_likelihood>;
1674 };
1675 template <> struct describe_field_t<SgAsmBlock,int64_t,&SgAsmBlock::p_stackDeltaOut> {
1676  using parent = SgAsmBlock;
1677  using field_type = int64_t;
1678  static constexpr size_t position{8};
1679  static constexpr char const * const name{"stackDeltaOut"};
1680  static constexpr char const * const typestr{"int64_t"};
1681  static constexpr bool traverse{false};
1682  static constexpr auto mbr_ptr{&SgAsmBlock::p_stackDeltaOut};
1683  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1684  using bind = Desc<SgAsmBlock, int64_t SgAsmBlock::*, &SgAsmBlock::p_stackDeltaOut>;
1685 };
1686 template <> struct describe_node_t<SgAsmBlock> {
1687  using node = SgAsmBlock;
1688  using base = SgAsmStatement;
1689  static constexpr char const * const name{"AsmBlock"};
1690  static constexpr unsigned long variant{62};
1691  static constexpr bool concrete{true};
1692  using subclasses_t = mp::List<>;
1694 };
1695 template <> struct node_from_variant_t<62> { using type = SgAsmBlock; };
1696 
1697 // Class: AsmCoffStrtab
1698 template <> struct describe_node_t<SgAsmCoffStrtab> {
1699  using node = SgAsmCoffStrtab;
1700  using base = SgAsmGenericStrtab;
1701  static constexpr char const * const name{"AsmCoffStrtab"};
1702  static constexpr unsigned long variant{63};
1703  static constexpr bool concrete{true};
1704  using subclasses_t = mp::List<>;
1705  using fields_t = mp::List<>;
1706 };
1707 template <> struct node_from_variant_t<63> { using type = SgAsmCoffStrtab; };
1708 
1709 // Class: AsmCoffSymbol
1710 template <> struct describe_field_t<SgAsmCoffSymbol,std::string,&SgAsmCoffSymbol::p_st_name> {
1711  using parent = SgAsmCoffSymbol;
1712  using field_type = std::string;
1713  static constexpr size_t position{0};
1714  static constexpr char const * const name{"st_name"};
1715  static constexpr char const * const typestr{"std::string"};
1716  static constexpr bool traverse{false};
1717  static constexpr auto mbr_ptr{&SgAsmCoffSymbol::p_st_name};
1718  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1719  using bind = Desc<SgAsmCoffSymbol, std::string SgAsmCoffSymbol::*, &SgAsmCoffSymbol::p_st_name>;
1720 };
1721 template <> struct describe_field_t<SgAsmCoffSymbol,rose_addr_t,&SgAsmCoffSymbol::p_st_name_offset> {
1722  using parent = SgAsmCoffSymbol;
1723  using field_type = rose_addr_t;
1724  static constexpr size_t position{1};
1725  static constexpr char const * const name{"st_name_offset"};
1726  static constexpr char const * const typestr{"rose_addr_t"};
1727  static constexpr bool traverse{false};
1728  static constexpr auto mbr_ptr{&SgAsmCoffSymbol::p_st_name_offset};
1729  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1730  using bind = Desc<SgAsmCoffSymbol, rose_addr_t SgAsmCoffSymbol::*, &SgAsmCoffSymbol::p_st_name_offset>;
1731 };
1732 template <> struct describe_field_t<SgAsmCoffSymbol,int,&SgAsmCoffSymbol::p_st_section_num> {
1733  using parent = SgAsmCoffSymbol;
1734  using field_type = int;
1735  static constexpr size_t position{2};
1736  static constexpr char const * const name{"st_section_num"};
1737  static constexpr char const * const typestr{"int"};
1738  static constexpr bool traverse{false};
1739  static constexpr auto mbr_ptr{&SgAsmCoffSymbol::p_st_section_num};
1740  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1741  using bind = Desc<SgAsmCoffSymbol, int SgAsmCoffSymbol::*, &SgAsmCoffSymbol::p_st_section_num>;
1742 };
1743 template <> struct describe_field_t<SgAsmCoffSymbol,unsigned,&SgAsmCoffSymbol::p_st_type> {
1744  using parent = SgAsmCoffSymbol;
1745  using field_type = unsigned;
1746  static constexpr size_t position{3};
1747  static constexpr char const * const name{"st_type"};
1748  static constexpr char const * const typestr{"unsigned"};
1749  static constexpr bool traverse{false};
1750  static constexpr auto mbr_ptr{&SgAsmCoffSymbol::p_st_type};
1751  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1752  using bind = Desc<SgAsmCoffSymbol, unsigned SgAsmCoffSymbol::*, &SgAsmCoffSymbol::p_st_type>;
1753 };
1754 template <> struct describe_field_t<SgAsmCoffSymbol,unsigned,&SgAsmCoffSymbol::p_st_storage_class> {
1755  using parent = SgAsmCoffSymbol;
1756  using field_type = unsigned;
1757  static constexpr size_t position{4};
1758  static constexpr char const * const name{"st_storage_class"};
1759  static constexpr char const * const typestr{"unsigned"};
1760  static constexpr bool traverse{false};
1761  static constexpr auto mbr_ptr{&SgAsmCoffSymbol::p_st_storage_class};
1762  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1763  using bind = Desc<SgAsmCoffSymbol, unsigned SgAsmCoffSymbol::*, &SgAsmCoffSymbol::p_st_storage_class>;
1764 };
1765 template <> struct describe_field_t<SgAsmCoffSymbol,unsigned,&SgAsmCoffSymbol::p_st_num_aux_entries> {
1766  using parent = SgAsmCoffSymbol;
1767  using field_type = unsigned;
1768  static constexpr size_t position{5};
1769  static constexpr char const * const name{"st_num_aux_entries"};
1770  static constexpr char const * const typestr{"unsigned"};
1771  static constexpr bool traverse{false};
1772  static constexpr auto mbr_ptr{&SgAsmCoffSymbol::p_st_num_aux_entries};
1773  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1774  using bind = Desc<SgAsmCoffSymbol, unsigned SgAsmCoffSymbol::*, &SgAsmCoffSymbol::p_st_num_aux_entries>;
1775 };
1776 template <> struct describe_field_t<SgAsmCoffSymbol,SgUnsignedCharList,&SgAsmCoffSymbol::p_aux_data> {
1777  using parent = SgAsmCoffSymbol;
1778  using field_type = SgUnsignedCharList;
1779  static constexpr size_t position{6};
1780  static constexpr char const * const name{"aux_data"};
1781  static constexpr char const * const typestr{"SgUnsignedCharList"};
1782  static constexpr bool traverse{false};
1783  static constexpr auto mbr_ptr{&SgAsmCoffSymbol::p_aux_data};
1784  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1785  using bind = Desc<SgAsmCoffSymbol, SgUnsignedCharList SgAsmCoffSymbol::*, &SgAsmCoffSymbol::p_aux_data>;
1786 };
1787 template <> struct describe_node_t<SgAsmCoffSymbol> {
1788  using node = SgAsmCoffSymbol;
1789  using base = SgAsmGenericSymbol;
1790  static constexpr char const * const name{"AsmCoffSymbol"};
1791  static constexpr unsigned long variant{64};
1792  static constexpr bool concrete{true};
1793  using subclasses_t = mp::List<>;
1795 };
1796 template <> struct node_from_variant_t<64> { using type = SgAsmCoffSymbol; };
1797 
1798 // Class: AsmCoffSymbolList
1799 template <> struct describe_field_t<SgAsmCoffSymbolList,SgAsmCoffSymbolPtrList,&SgAsmCoffSymbolList::p_symbols> {
1800  using parent = SgAsmCoffSymbolList;
1801  using field_type = SgAsmCoffSymbolPtrList;
1802  static constexpr size_t position{0};
1803  static constexpr char const * const name{"symbols"};
1804  static constexpr char const * const typestr{"SgAsmCoffSymbolPtrList"};
1805  static constexpr bool traverse{true};
1806  static constexpr auto mbr_ptr{&SgAsmCoffSymbolList::p_symbols};
1807  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1808  using bind = Desc<SgAsmCoffSymbolList, SgAsmCoffSymbolPtrList SgAsmCoffSymbolList::*, &SgAsmCoffSymbolList::p_symbols>;
1809 };
1811  using node = SgAsmCoffSymbolList;
1813  static constexpr char const * const name{"AsmCoffSymbolList"};
1814  static constexpr unsigned long variant{65};
1815  static constexpr bool concrete{true};
1816  using subclasses_t = mp::List<>;
1818 };
1819 template <> struct node_from_variant_t<65> { using type = SgAsmCoffSymbolList; };
1820 
1821 // Class: AsmCoffSymbolTable
1822 template <> struct describe_field_t<SgAsmCoffSymbolTable,SgAsmGenericSection*,&SgAsmCoffSymbolTable::p_strtab> {
1823  using parent = SgAsmCoffSymbolTable;
1825  static constexpr size_t position{0};
1826  static constexpr char const * const name{"strtab"};
1827  static constexpr char const * const typestr{"SgAsmGenericSection*"};
1828  static constexpr bool traverse{false};
1829  static constexpr auto mbr_ptr{&SgAsmCoffSymbolTable::p_strtab};
1830  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1831  using bind = Desc<SgAsmCoffSymbolTable, SgAsmGenericSection* SgAsmCoffSymbolTable::*, &SgAsmCoffSymbolTable::p_strtab>;
1832 };
1833 template <> struct describe_field_t<SgAsmCoffSymbolTable,SgAsmCoffSymbolList*,&SgAsmCoffSymbolTable::p_symbols> {
1834  using parent = SgAsmCoffSymbolTable;
1836  static constexpr size_t position{1};
1837  static constexpr char const * const name{"symbols"};
1838  static constexpr char const * const typestr{"SgAsmCoffSymbolList*"};
1839  static constexpr bool traverse{true};
1840  static constexpr auto mbr_ptr{&SgAsmCoffSymbolTable::p_symbols};
1841  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1842  using bind = Desc<SgAsmCoffSymbolTable, SgAsmCoffSymbolList* SgAsmCoffSymbolTable::*, &SgAsmCoffSymbolTable::p_symbols>;
1843 };
1845  using node = SgAsmCoffSymbolTable;
1846  using base = SgAsmGenericSection;
1847  static constexpr char const * const name{"AsmCoffSymbolTable"};
1848  static constexpr unsigned long variant{66};
1849  static constexpr bool concrete{true};
1850  using subclasses_t = mp::List<>;
1852 };
1853 template <> struct node_from_variant_t<66> { using type = SgAsmCoffSymbolTable; };
1854 
1855 // Class: AsmCommonSubExpression
1856 template <> struct describe_field_t<SgAsmCommonSubExpression,SgAsmExpression*,&SgAsmCommonSubExpression::p_subexpression> {
1857  using parent = SgAsmCommonSubExpression;
1858  using field_type = SgAsmExpression*;
1859  static constexpr size_t position{0};
1860  static constexpr char const * const name{"subexpression"};
1861  static constexpr char const * const typestr{"SgAsmExpression*"};
1862  static constexpr bool traverse{true};
1863  static constexpr auto mbr_ptr{&SgAsmCommonSubExpression::p_subexpression};
1864  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1865  using bind = Desc<SgAsmCommonSubExpression, SgAsmExpression* SgAsmCommonSubExpression::*, &SgAsmCommonSubExpression::p_subexpression>;
1866 };
1867 template <> struct describe_node_t<SgAsmCommonSubExpression> {
1868  using node = SgAsmCommonSubExpression;
1869  using base = SgAsmExpression;
1870  static constexpr char const * const name{"AsmCommonSubExpression"};
1871  static constexpr unsigned long variant{67};
1872  static constexpr bool concrete{true};
1873  using subclasses_t = mp::List<>;
1875 };
1876 template <> struct node_from_variant_t<67> { using type = SgAsmCommonSubExpression; };
1877 
1878 // Class: AsmControlFlagsExpression
1879 template <> struct describe_field_t<SgAsmControlFlagsExpression,unsigned long,&SgAsmControlFlagsExpression::p_bit_flags> {
1881  using field_type = unsigned long;
1882  static constexpr size_t position{0};
1883  static constexpr char const * const name{"bit_flags"};
1884  static constexpr char const * const typestr{"unsigned long"};
1885  static constexpr bool traverse{false};
1886  static constexpr auto mbr_ptr{&SgAsmControlFlagsExpression::p_bit_flags};
1887  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1888  using bind = Desc<SgAsmControlFlagsExpression, unsigned long SgAsmControlFlagsExpression::*, &SgAsmControlFlagsExpression::p_bit_flags>;
1889 };
1892  using base = SgAsmExpression;
1893  static constexpr char const * const name{"AsmControlFlagsExpression"};
1894  static constexpr unsigned long variant{68};
1895  static constexpr bool concrete{true};
1896  using subclasses_t = mp::List<>;
1898 };
1899 template <> struct node_from_variant_t<68> { using type = SgAsmControlFlagsExpression; };
1900 
1901 // Class: AsmConstantExpression
1902 template <> struct describe_field_t<SgAsmConstantExpression,Sawyer::Container::BitVector,&SgAsmConstantExpression::p_bitVector> {
1905  static constexpr size_t position{0};
1906  static constexpr char const * const name{"bitVector"};
1907  static constexpr char const * const typestr{"Sawyer::Container::BitVector"};
1908  static constexpr bool traverse{false};
1909  static constexpr auto mbr_ptr{&SgAsmConstantExpression::p_bitVector};
1910  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1911  using bind = Desc<SgAsmConstantExpression, Sawyer::Container::BitVector SgAsmConstantExpression::*, &SgAsmConstantExpression::p_bitVector>;
1912 };
1914  using node = SgAsmConstantExpression;
1915  using base = SgAsmValueExpression;
1916  static constexpr char const * const name{"AsmConstantExpression"};
1917  static constexpr unsigned long variant{69};
1918  static constexpr bool concrete{false};
1921 };
1922 template <> struct node_from_variant_t<69> { using type = SgAsmConstantExpression; };
1923 
1924 // Class: AsmDOSExtendedHeader
1925 template <> struct describe_field_t<SgAsmDOSExtendedHeader,unsigned,&SgAsmDOSExtendedHeader::p_e_res1> {
1927  using field_type = unsigned;
1928  static constexpr size_t position{0};
1929  static constexpr char const * const name{"e_res1"};
1930  static constexpr char const * const typestr{"unsigned"};
1931  static constexpr bool traverse{false};
1932  static constexpr auto mbr_ptr{&SgAsmDOSExtendedHeader::p_e_res1};
1933  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1934  using bind = Desc<SgAsmDOSExtendedHeader, unsigned SgAsmDOSExtendedHeader::*, &SgAsmDOSExtendedHeader::p_e_res1>;
1935 };
1936 template <> struct describe_field_t<SgAsmDOSExtendedHeader,unsigned,&SgAsmDOSExtendedHeader::p_e_oemid> {
1938  using field_type = unsigned;
1939  static constexpr size_t position{1};
1940  static constexpr char const * const name{"e_oemid"};
1941  static constexpr char const * const typestr{"unsigned"};
1942  static constexpr bool traverse{false};
1943  static constexpr auto mbr_ptr{&SgAsmDOSExtendedHeader::p_e_oemid};
1944  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1945  using bind = Desc<SgAsmDOSExtendedHeader, unsigned SgAsmDOSExtendedHeader::*, &SgAsmDOSExtendedHeader::p_e_oemid>;
1946 };
1947 template <> struct describe_field_t<SgAsmDOSExtendedHeader,unsigned,&SgAsmDOSExtendedHeader::p_e_oeminfo> {
1949  using field_type = unsigned;
1950  static constexpr size_t position{2};
1951  static constexpr char const * const name{"e_oeminfo"};
1952  static constexpr char const * const typestr{"unsigned"};
1953  static constexpr bool traverse{false};
1954  static constexpr auto mbr_ptr{&SgAsmDOSExtendedHeader::p_e_oeminfo};
1955  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1956  using bind = Desc<SgAsmDOSExtendedHeader, unsigned SgAsmDOSExtendedHeader::*, &SgAsmDOSExtendedHeader::p_e_oeminfo>;
1957 };
1958 template <> struct describe_field_t<SgAsmDOSExtendedHeader,unsigned,&SgAsmDOSExtendedHeader::p_e_res2> {
1960  using field_type = unsigned;
1961  static constexpr size_t position{3};
1962  static constexpr char const * const name{"e_res2"};
1963  static constexpr char const * const typestr{"unsigned"};
1964  static constexpr bool traverse{false};
1965  static constexpr auto mbr_ptr{&SgAsmDOSExtendedHeader::p_e_res2};
1966  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1967  using bind = Desc<SgAsmDOSExtendedHeader, unsigned SgAsmDOSExtendedHeader::*, &SgAsmDOSExtendedHeader::p_e_res2>;
1968 };
1969 template <> struct describe_field_t<SgAsmDOSExtendedHeader,unsigned,&SgAsmDOSExtendedHeader::p_e_res3> {
1971  using field_type = unsigned;
1972  static constexpr size_t position{4};
1973  static constexpr char const * const name{"e_res3"};
1974  static constexpr char const * const typestr{"unsigned"};
1975  static constexpr bool traverse{false};
1976  static constexpr auto mbr_ptr{&SgAsmDOSExtendedHeader::p_e_res3};
1977  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1978  using bind = Desc<SgAsmDOSExtendedHeader, unsigned SgAsmDOSExtendedHeader::*, &SgAsmDOSExtendedHeader::p_e_res3>;
1979 };
1980 template <> struct describe_field_t<SgAsmDOSExtendedHeader,unsigned,&SgAsmDOSExtendedHeader::p_e_res4> {
1982  using field_type = unsigned;
1983  static constexpr size_t position{5};
1984  static constexpr char const * const name{"e_res4"};
1985  static constexpr char const * const typestr{"unsigned"};
1986  static constexpr bool traverse{false};
1987  static constexpr auto mbr_ptr{&SgAsmDOSExtendedHeader::p_e_res4};
1988  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
1989  using bind = Desc<SgAsmDOSExtendedHeader, unsigned SgAsmDOSExtendedHeader::*, &SgAsmDOSExtendedHeader::p_e_res4>;
1990 };
1991 template <> struct describe_field_t<SgAsmDOSExtendedHeader,unsigned,&SgAsmDOSExtendedHeader::p_e_res5> {
1993  using field_type = unsigned;
1994  static constexpr size_t position{6};
1995  static constexpr char const * const name{"e_res5"};
1996  static constexpr char const * const typestr{"unsigned"};
1997  static constexpr bool traverse{false};
1998  static constexpr auto mbr_ptr{&SgAsmDOSExtendedHeader::p_e_res5};
1999  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2000  using bind = Desc<SgAsmDOSExtendedHeader, unsigned SgAsmDOSExtendedHeader::*, &SgAsmDOSExtendedHeader::p_e_res5>;
2001 };
2002 template <> struct describe_field_t<SgAsmDOSExtendedHeader,unsigned,&SgAsmDOSExtendedHeader::p_e_res6> {
2004  using field_type = unsigned;
2005  static constexpr size_t position{7};
2006  static constexpr char const * const name{"e_res6"};
2007  static constexpr char const * const typestr{"unsigned"};
2008  static constexpr bool traverse{false};
2009  static constexpr auto mbr_ptr{&SgAsmDOSExtendedHeader::p_e_res6};
2010  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2011  using bind = Desc<SgAsmDOSExtendedHeader, unsigned SgAsmDOSExtendedHeader::*, &SgAsmDOSExtendedHeader::p_e_res6>;
2012 };
2013 template <> struct describe_field_t<SgAsmDOSExtendedHeader,rose_addr_t,&SgAsmDOSExtendedHeader::p_e_lfanew> {
2015  using field_type = rose_addr_t;
2016  static constexpr size_t position{8};
2017  static constexpr char const * const name{"e_lfanew"};
2018  static constexpr char const * const typestr{"rose_addr_t"};
2019  static constexpr bool traverse{false};
2020  static constexpr auto mbr_ptr{&SgAsmDOSExtendedHeader::p_e_lfanew};
2021  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2022  using bind = Desc<SgAsmDOSExtendedHeader, rose_addr_t SgAsmDOSExtendedHeader::*, &SgAsmDOSExtendedHeader::p_e_lfanew>;
2023 };
2025  using node = SgAsmDOSExtendedHeader;
2026  using base = SgAsmGenericSection;
2027  static constexpr char const * const name{"AsmDOSExtendedHeader"};
2028  static constexpr unsigned long variant{70};
2029  static constexpr bool concrete{true};
2030  using subclasses_t = mp::List<>;
2032 };
2033 template <> struct node_from_variant_t<70> { using type = SgAsmDOSExtendedHeader; };
2034 
2035 // Class: AsmDOSFileHeader
2036 template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_last_page_size> {
2037  using parent = SgAsmDOSFileHeader;
2038  using field_type = uint16_t;
2039  static constexpr size_t position{0};
2040  static constexpr char const * const name{"e_last_page_size"};
2041  static constexpr char const * const typestr{"uint16_t"};
2042  static constexpr bool traverse{false};
2043  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_last_page_size};
2044  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2045  using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_last_page_size>;
2046 };
2047 template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_total_pages> {
2048  using parent = SgAsmDOSFileHeader;
2049  using field_type = uint16_t;
2050  static constexpr size_t position{1};
2051  static constexpr char const * const name{"e_total_pages"};
2052  static constexpr char const * const typestr{"uint16_t"};
2053  static constexpr bool traverse{false};
2054  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_total_pages};
2055  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2056  using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_total_pages>;
2057 };
2058 template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_nrelocs> {
2059  using parent = SgAsmDOSFileHeader;
2060  using field_type = uint16_t;
2061  static constexpr size_t position{2};
2062  static constexpr char const * const name{"e_nrelocs"};
2063  static constexpr char const * const typestr{"uint16_t"};
2064  static constexpr bool traverse{false};
2065  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_nrelocs};
2066  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2067  using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_nrelocs>;
2068 };
2069 template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_header_paragraphs> {
2070  using parent = SgAsmDOSFileHeader;
2071  using field_type = uint16_t;
2072  static constexpr size_t position{3};
2073  static constexpr char const * const name{"e_header_paragraphs"};
2074  static constexpr char const * const typestr{"uint16_t"};
2075  static constexpr bool traverse{false};
2076  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_header_paragraphs};
2077  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2078  using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_header_paragraphs>;
2079 };
2080 template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_minalloc> {
2081  using parent = SgAsmDOSFileHeader;
2082  using field_type = uint16_t;
2083  static constexpr size_t position{4};
2084  static constexpr char const * const name{"e_minalloc"};
2085  static constexpr char const * const typestr{"uint16_t"};
2086  static constexpr bool traverse{false};
2087  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_minalloc};
2088  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2089  using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_minalloc>;
2090 };
2091 template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_maxalloc> {
2092  using parent = SgAsmDOSFileHeader;
2093  using field_type = uint16_t;
2094  static constexpr size_t position{5};
2095  static constexpr char const * const name{"e_maxalloc"};
2096  static constexpr char const * const typestr{"uint16_t"};
2097  static constexpr bool traverse{false};
2098  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_maxalloc};
2099  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2100  using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_maxalloc>;
2101 };
2102 template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_ss> {
2103  using parent = SgAsmDOSFileHeader;
2104  using field_type = uint16_t;
2105  static constexpr size_t position{6};
2106  static constexpr char const * const name{"e_ss"};
2107  static constexpr char const * const typestr{"uint16_t"};
2108  static constexpr bool traverse{false};
2109  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_ss};
2110  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2111  using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_ss>;
2112 };
2113 template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_sp> {
2114  using parent = SgAsmDOSFileHeader;
2115  using field_type = uint16_t;
2116  static constexpr size_t position{7};
2117  static constexpr char const * const name{"e_sp"};
2118  static constexpr char const * const typestr{"uint16_t"};
2119  static constexpr bool traverse{false};
2120  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_sp};
2121  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2122  using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_sp>;
2123 };
2124 template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_cksum> {
2125  using parent = SgAsmDOSFileHeader;
2126  using field_type = uint16_t;
2127  static constexpr size_t position{8};
2128  static constexpr char const * const name{"e_cksum"};
2129  static constexpr char const * const typestr{"uint16_t"};
2130  static constexpr bool traverse{false};
2131  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_cksum};
2132  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2133  using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_cksum>;
2134 };
2135 template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_ip> {
2136  using parent = SgAsmDOSFileHeader;
2137  using field_type = uint16_t;
2138  static constexpr size_t position{9};
2139  static constexpr char const * const name{"e_ip"};
2140  static constexpr char const * const typestr{"uint16_t"};
2141  static constexpr bool traverse{false};
2142  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_ip};
2143  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2144  using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_ip>;
2145 };
2146 template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_cs> {
2147  using parent = SgAsmDOSFileHeader;
2148  using field_type = uint16_t;
2149  static constexpr size_t position{10};
2150  static constexpr char const * const name{"e_cs"};
2151  static constexpr char const * const typestr{"uint16_t"};
2152  static constexpr bool traverse{false};
2153  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_cs};
2154  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2155  using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_cs>;
2156 };
2157 template <> struct describe_field_t<SgAsmDOSFileHeader,uint16_t,&SgAsmDOSFileHeader::p_e_overlay> {
2158  using parent = SgAsmDOSFileHeader;
2159  using field_type = uint16_t;
2160  static constexpr size_t position{11};
2161  static constexpr char const * const name{"e_overlay"};
2162  static constexpr char const * const typestr{"uint16_t"};
2163  static constexpr bool traverse{false};
2164  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_overlay};
2165  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2166  using bind = Desc<SgAsmDOSFileHeader, uint16_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_overlay>;
2167 };
2168 template <> struct describe_field_t<SgAsmDOSFileHeader,rose_addr_t,&SgAsmDOSFileHeader::p_e_relocs_offset> {
2169  using parent = SgAsmDOSFileHeader;
2170  using field_type = rose_addr_t;
2171  static constexpr size_t position{12};
2172  static constexpr char const * const name{"e_relocs_offset"};
2173  static constexpr char const * const typestr{"rose_addr_t"};
2174  static constexpr bool traverse{false};
2175  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_relocs_offset};
2176  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2177  using bind = Desc<SgAsmDOSFileHeader, rose_addr_t SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_relocs_offset>;
2178 };
2179 template <> struct describe_field_t<SgAsmDOSFileHeader,unsigned,&SgAsmDOSFileHeader::p_e_res1> {
2180  using parent = SgAsmDOSFileHeader;
2181  using field_type = unsigned;
2182  static constexpr size_t position{13};
2183  static constexpr char const * const name{"e_res1"};
2184  static constexpr char const * const typestr{"unsigned"};
2185  static constexpr bool traverse{false};
2186  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_e_res1};
2187  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2188  using bind = Desc<SgAsmDOSFileHeader, unsigned SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_e_res1>;
2189 };
2190 template <> struct describe_field_t<SgAsmDOSFileHeader,SgAsmGenericSection*,&SgAsmDOSFileHeader::p_relocs> {
2191  using parent = SgAsmDOSFileHeader;
2193  static constexpr size_t position{14};
2194  static constexpr char const * const name{"relocs"};
2195  static constexpr char const * const typestr{"SgAsmGenericSection*"};
2196  static constexpr bool traverse{true};
2197  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_relocs};
2198  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2199  using bind = Desc<SgAsmDOSFileHeader, SgAsmGenericSection* SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_relocs>;
2200 };
2201 template <> struct describe_field_t<SgAsmDOSFileHeader,SgAsmGenericSection*,&SgAsmDOSFileHeader::p_rm_section> {
2202  using parent = SgAsmDOSFileHeader;
2204  static constexpr size_t position{15};
2205  static constexpr char const * const name{"rm_section"};
2206  static constexpr char const * const typestr{"SgAsmGenericSection*"};
2207  static constexpr bool traverse{false};
2208  static constexpr auto mbr_ptr{&SgAsmDOSFileHeader::p_rm_section};
2209  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2210  using bind = Desc<SgAsmDOSFileHeader, SgAsmGenericSection* SgAsmDOSFileHeader::*, &SgAsmDOSFileHeader::p_rm_section>;
2211 };
2213  using node = SgAsmDOSFileHeader;
2214  using base = SgAsmGenericHeader;
2215  static constexpr char const * const name{"AsmDOSFileHeader"};
2216  static constexpr unsigned long variant{71};
2217  static constexpr bool concrete{true};
2218  using subclasses_t = mp::List<>;
2220 };
2221 template <> struct node_from_variant_t<71> { using type = SgAsmDOSFileHeader; };
2222 
2223 // Class: AsmSynthesizedDataStructureDeclaration
2227  static constexpr char const * const name{"AsmSynthesizedDataStructureDeclaration"};
2228  static constexpr unsigned long variant{72};
2229  static constexpr bool concrete{true};
2230  using subclasses_t = mp::List<>;
2231  using fields_t = mp::List<>;
2232 };
2233 template <> struct node_from_variant_t<72> { using type = SgAsmSynthesizedDataStructureDeclaration; };
2234 
2235 // Class: AsmSynthesizedDeclaration
2238  using base = SgAsmStatement;
2239  static constexpr char const * const name{"AsmSynthesizedDeclaration"};
2240  static constexpr unsigned long variant{73};
2241  static constexpr bool concrete{false};
2243  using fields_t = mp::List<>;
2244 };
2245 template <> struct node_from_variant_t<73> { using type = SgAsmSynthesizedDeclaration; };
2246 
2247 // Class: AsmDirectRegisterExpression
2251  static constexpr char const * const name{"AsmDirectRegisterExpression"};
2252  static constexpr unsigned long variant{74};
2253  static constexpr bool concrete{true};
2254  using subclasses_t = mp::List<>;
2255  using fields_t = mp::List<>;
2256 };
2257 template <> struct node_from_variant_t<74> { using type = SgAsmDirectRegisterExpression; };
2258 
2259 // Class: AsmDwarfAccessDeclaration
2262  using base = SgAsmDwarfConstruct;
2263  static constexpr char const * const name{"AsmDwarfAccessDeclaration"};
2264  static constexpr unsigned long variant{75};
2265  static constexpr bool concrete{true};
2266  using subclasses_t = mp::List<>;
2267  using fields_t = mp::List<>;
2268 };
2269 template <> struct node_from_variant_t<75> { using type = SgAsmDwarfAccessDeclaration; };
2270 
2271 // Class: AsmDwarfArrayType
2272 template <> struct describe_field_t<SgAsmDwarfArrayType,SgAsmDwarfConstructList*,&SgAsmDwarfArrayType::p_body> {
2273  using parent = SgAsmDwarfArrayType;
2275  static constexpr size_t position{0};
2276  static constexpr char const * const name{"body"};
2277  static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
2278  static constexpr bool traverse{true};
2279  static constexpr auto mbr_ptr{&SgAsmDwarfArrayType::p_body};
2280  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2281  using bind = Desc<SgAsmDwarfArrayType, SgAsmDwarfConstructList* SgAsmDwarfArrayType::*, &SgAsmDwarfArrayType::p_body>;
2282 };
2284  using node = SgAsmDwarfArrayType;
2285  using base = SgAsmDwarfConstruct;
2286  static constexpr char const * const name{"AsmDwarfArrayType"};
2287  static constexpr unsigned long variant{76};
2288  static constexpr bool concrete{true};
2289  using subclasses_t = mp::List<>;
2291 };
2292 template <> struct node_from_variant_t<76> { using type = SgAsmDwarfArrayType; };
2293 
2294 // Class: AsmDwarfBaseType
2296  using node = SgAsmDwarfBaseType;
2297  using base = SgAsmDwarfConstruct;
2298  static constexpr char const * const name{"AsmDwarfBaseType"};
2299  static constexpr unsigned long variant{77};
2300  static constexpr bool concrete{true};
2301  using subclasses_t = mp::List<>;
2302  using fields_t = mp::List<>;
2303 };
2304 template <> struct node_from_variant_t<77> { using type = SgAsmDwarfBaseType; };
2305 
2306 // Class: AsmDwarfCatchBlock
2308  using node = SgAsmDwarfCatchBlock;
2309  using base = SgAsmDwarfConstruct;
2310  static constexpr char const * const name{"AsmDwarfCatchBlock"};
2311  static constexpr unsigned long variant{78};
2312  static constexpr bool concrete{true};
2313  using subclasses_t = mp::List<>;
2314  using fields_t = mp::List<>;
2315 };
2316 template <> struct node_from_variant_t<78> { using type = SgAsmDwarfCatchBlock; };
2317 
2318 // Class: AsmDwarfClassTemplate
2320  using node = SgAsmDwarfClassTemplate;
2321  using base = SgAsmDwarfConstruct;
2322  static constexpr char const * const name{"AsmDwarfClassTemplate"};
2323  static constexpr unsigned long variant{79};
2324  static constexpr bool concrete{true};
2325  using subclasses_t = mp::List<>;
2326  using fields_t = mp::List<>;
2327 };
2328 template <> struct node_from_variant_t<79> { using type = SgAsmDwarfClassTemplate; };
2329 
2330 // Class: AsmDwarfClassType
2331 template <> struct describe_field_t<SgAsmDwarfClassType,SgAsmDwarfConstructList*,&SgAsmDwarfClassType::p_body> {
2332  using parent = SgAsmDwarfClassType;
2334  static constexpr size_t position{0};
2335  static constexpr char const * const name{"body"};
2336  static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
2337  static constexpr bool traverse{true};
2338  static constexpr auto mbr_ptr{&SgAsmDwarfClassType::p_body};
2339  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2340  using bind = Desc<SgAsmDwarfClassType, SgAsmDwarfConstructList* SgAsmDwarfClassType::*, &SgAsmDwarfClassType::p_body>;
2341 };
2343  using node = SgAsmDwarfClassType;
2344  using base = SgAsmDwarfConstruct;
2345  static constexpr char const * const name{"AsmDwarfClassType"};
2346  static constexpr unsigned long variant{80};
2347  static constexpr bool concrete{true};
2348  using subclasses_t = mp::List<>;
2350 };
2351 template <> struct node_from_variant_t<80> { using type = SgAsmDwarfClassType; };
2352 
2353 // Class: AsmDwarfCommonBlock
2354 template <> struct describe_field_t<SgAsmDwarfCommonBlock,SgAsmDwarfConstructList*,&SgAsmDwarfCommonBlock::p_body> {
2355  using parent = SgAsmDwarfCommonBlock;
2357  static constexpr size_t position{0};
2358  static constexpr char const * const name{"body"};
2359  static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
2360  static constexpr bool traverse{true};
2361  static constexpr auto mbr_ptr{&SgAsmDwarfCommonBlock::p_body};
2362  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2363  using bind = Desc<SgAsmDwarfCommonBlock, SgAsmDwarfConstructList* SgAsmDwarfCommonBlock::*, &SgAsmDwarfCommonBlock::p_body>;
2364 };
2366  using node = SgAsmDwarfCommonBlock;
2367  using base = SgAsmDwarfConstruct;
2368  static constexpr char const * const name{"AsmDwarfCommonBlock"};
2369  static constexpr unsigned long variant{81};
2370  static constexpr bool concrete{true};
2371  using subclasses_t = mp::List<>;
2373 };
2374 template <> struct node_from_variant_t<81> { using type = SgAsmDwarfCommonBlock; };
2375 
2376 // Class: AsmDwarfCommonInclusion
2379  using base = SgAsmDwarfConstruct;
2380  static constexpr char const * const name{"AsmDwarfCommonInclusion"};
2381  static constexpr unsigned long variant{82};
2382  static constexpr bool concrete{true};
2383  using subclasses_t = mp::List<>;
2384  using fields_t = mp::List<>;
2385 };
2386 template <> struct node_from_variant_t<82> { using type = SgAsmDwarfCommonInclusion; };
2387 
2388 // Class: AsmDwarfCompilationUnit
2389 template <> struct describe_field_t<SgAsmDwarfCompilationUnit,std::string,&SgAsmDwarfCompilationUnit::p_producer> {
2391  using field_type = std::string;
2392  static constexpr size_t position{0};
2393  static constexpr char const * const name{"producer"};
2394  static constexpr char const * const typestr{"std::string"};
2395  static constexpr bool traverse{false};
2396  static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnit::p_producer};
2397  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2398  using bind = Desc<SgAsmDwarfCompilationUnit, std::string SgAsmDwarfCompilationUnit::*, &SgAsmDwarfCompilationUnit::p_producer>;
2399 };
2400 template <> struct describe_field_t<SgAsmDwarfCompilationUnit,std::string,&SgAsmDwarfCompilationUnit::p_language> {
2402  using field_type = std::string;
2403  static constexpr size_t position{1};
2404  static constexpr char const * const name{"language"};
2405  static constexpr char const * const typestr{"std::string"};
2406  static constexpr bool traverse{false};
2407  static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnit::p_language};
2408  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2409  using bind = Desc<SgAsmDwarfCompilationUnit, std::string SgAsmDwarfCompilationUnit::*, &SgAsmDwarfCompilationUnit::p_language>;
2410 };
2411 template <> struct describe_field_t<SgAsmDwarfCompilationUnit,uint64_t,&SgAsmDwarfCompilationUnit::p_low_pc> {
2413  using field_type = uint64_t;
2414  static constexpr size_t position{2};
2415  static constexpr char const * const name{"low_pc"};
2416  static constexpr char const * const typestr{"uint64_t"};
2417  static constexpr bool traverse{false};
2418  static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnit::p_low_pc};
2419  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2420  using bind = Desc<SgAsmDwarfCompilationUnit, uint64_t SgAsmDwarfCompilationUnit::*, &SgAsmDwarfCompilationUnit::p_low_pc>;
2421 };
2422 template <> struct describe_field_t<SgAsmDwarfCompilationUnit,uint64_t,&SgAsmDwarfCompilationUnit::p_hi_pc> {
2424  using field_type = uint64_t;
2425  static constexpr size_t position{3};
2426  static constexpr char const * const name{"hi_pc"};
2427  static constexpr char const * const typestr{"uint64_t"};
2428  static constexpr bool traverse{false};
2429  static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnit::p_hi_pc};
2430  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2431  using bind = Desc<SgAsmDwarfCompilationUnit, uint64_t SgAsmDwarfCompilationUnit::*, &SgAsmDwarfCompilationUnit::p_hi_pc>;
2432 };
2433 template <> struct describe_field_t<SgAsmDwarfCompilationUnit,int,&SgAsmDwarfCompilationUnit::p_version_stamp> {
2435  using field_type = int;
2436  static constexpr size_t position{4};
2437  static constexpr char const * const name{"version_stamp"};
2438  static constexpr char const * const typestr{"int"};
2439  static constexpr bool traverse{false};
2440  static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnit::p_version_stamp};
2441  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2442  using bind = Desc<SgAsmDwarfCompilationUnit, int SgAsmDwarfCompilationUnit::*, &SgAsmDwarfCompilationUnit::p_version_stamp>;
2443 };
2444 template <> struct describe_field_t<SgAsmDwarfCompilationUnit,uint64_t,&SgAsmDwarfCompilationUnit::p_abbrev_offset> {
2446  using field_type = uint64_t;
2447  static constexpr size_t position{5};
2448  static constexpr char const * const name{"abbrev_offset"};
2449  static constexpr char const * const typestr{"uint64_t"};
2450  static constexpr bool traverse{false};
2451  static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnit::p_abbrev_offset};
2452  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2453  using bind = Desc<SgAsmDwarfCompilationUnit, uint64_t SgAsmDwarfCompilationUnit::*, &SgAsmDwarfCompilationUnit::p_abbrev_offset>;
2454 };
2455 template <> struct describe_field_t<SgAsmDwarfCompilationUnit,uint64_t,&SgAsmDwarfCompilationUnit::p_address_size> {
2457  using field_type = uint64_t;
2458  static constexpr size_t position{6};
2459  static constexpr char const * const name{"address_size"};
2460  static constexpr char const * const typestr{"uint64_t"};
2461  static constexpr bool traverse{false};
2462  static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnit::p_address_size};
2463  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2464  using bind = Desc<SgAsmDwarfCompilationUnit, uint64_t SgAsmDwarfCompilationUnit::*, &SgAsmDwarfCompilationUnit::p_address_size>;
2465 };
2466 template <> struct describe_field_t<SgAsmDwarfCompilationUnit,uint64_t,&SgAsmDwarfCompilationUnit::p_offset_length> {
2468  using field_type = uint64_t;
2469  static constexpr size_t position{7};
2470  static constexpr char const * const name{"offset_length"};
2471  static constexpr char const * const typestr{"uint64_t"};
2472  static constexpr bool traverse{false};
2473  static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnit::p_offset_length};
2474  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2475  using bind = Desc<SgAsmDwarfCompilationUnit, uint64_t SgAsmDwarfCompilationUnit::*, &SgAsmDwarfCompilationUnit::p_offset_length>;
2476 };
2477 template <> struct describe_field_t<SgAsmDwarfCompilationUnit,SgAsmDwarfLineList*,&SgAsmDwarfCompilationUnit::p_line_info> {
2479  using field_type = SgAsmDwarfLineList*;
2480  static constexpr size_t position{8};
2481  static constexpr char const * const name{"line_info"};
2482  static constexpr char const * const typestr{"SgAsmDwarfLineList*"};
2483  static constexpr bool traverse{true};
2484  static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnit::p_line_info};
2485  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2486  using bind = Desc<SgAsmDwarfCompilationUnit, SgAsmDwarfLineList* SgAsmDwarfCompilationUnit::*, &SgAsmDwarfCompilationUnit::p_line_info>;
2487 };
2488 template <> struct describe_field_t<SgAsmDwarfCompilationUnit,SgAsmDwarfConstructList*,&SgAsmDwarfCompilationUnit::p_language_constructs> {
2491  static constexpr size_t position{9};
2492  static constexpr char const * const name{"language_constructs"};
2493  static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
2494  static constexpr bool traverse{true};
2495  static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnit::p_language_constructs};
2496  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2497  using bind = Desc<SgAsmDwarfCompilationUnit, SgAsmDwarfConstructList* SgAsmDwarfCompilationUnit::*, &SgAsmDwarfCompilationUnit::p_language_constructs>;
2498 };
2499 template <> struct describe_field_t<SgAsmDwarfCompilationUnit,SgAsmDwarfMacroList*,&SgAsmDwarfCompilationUnit::p_macro_info> {
2502  static constexpr size_t position{10};
2503  static constexpr char const * const name{"macro_info"};
2504  static constexpr char const * const typestr{"SgAsmDwarfMacroList*"};
2505  static constexpr bool traverse{true};
2506  static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnit::p_macro_info};
2507  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2508  using bind = Desc<SgAsmDwarfCompilationUnit, SgAsmDwarfMacroList* SgAsmDwarfCompilationUnit::*, &SgAsmDwarfCompilationUnit::p_macro_info>;
2509 };
2512  using base = SgAsmDwarfConstruct;
2513  static constexpr char const * const name{"AsmDwarfCompilationUnit"};
2514  static constexpr unsigned long variant{83};
2515  static constexpr bool concrete{true};
2516  using subclasses_t = mp::List<>;
2518 };
2519 template <> struct node_from_variant_t<83> { using type = SgAsmDwarfCompilationUnit; };
2520 
2521 // Class: AsmDwarfCompilationUnitList
2522 template <> struct describe_field_t<SgAsmDwarfCompilationUnitList,SgAsmDwarfCompilationUnitPtrList,&SgAsmDwarfCompilationUnitList::p_cu_list> {
2524  using field_type = SgAsmDwarfCompilationUnitPtrList;
2525  static constexpr size_t position{0};
2526  static constexpr char const * const name{"cu_list"};
2527  static constexpr char const * const typestr{"SgAsmDwarfCompilationUnitPtrList"};
2528  static constexpr bool traverse{true};
2529  static constexpr auto mbr_ptr{&SgAsmDwarfCompilationUnitList::p_cu_list};
2530  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2531  using bind = Desc<SgAsmDwarfCompilationUnitList, SgAsmDwarfCompilationUnitPtrList SgAsmDwarfCompilationUnitList::*, &SgAsmDwarfCompilationUnitList::p_cu_list>;
2532 };
2535  using base = SgAsmDwarfInformation;
2536  static constexpr char const * const name{"AsmDwarfCompilationUnitList"};
2537  static constexpr unsigned long variant{84};
2538  static constexpr bool concrete{true};
2539  using subclasses_t = mp::List<>;
2541 };
2542 template <> struct node_from_variant_t<84> { using type = SgAsmDwarfCompilationUnitList; };
2543 
2544 // Class: AsmDwarfCondition
2546  using node = SgAsmDwarfCondition;
2547  using base = SgAsmDwarfConstruct;
2548  static constexpr char const * const name{"AsmDwarfCondition"};
2549  static constexpr unsigned long variant{85};
2550  static constexpr bool concrete{true};
2551  using subclasses_t = mp::List<>;
2552  using fields_t = mp::List<>;
2553 };
2554 template <> struct node_from_variant_t<85> { using type = SgAsmDwarfCondition; };
2555 
2556 // Class: AsmDwarfConstType
2558  using node = SgAsmDwarfConstType;
2559  using base = SgAsmDwarfConstruct;
2560  static constexpr char const * const name{"AsmDwarfConstType"};
2561  static constexpr unsigned long variant{86};
2562  static constexpr bool concrete{true};
2563  using subclasses_t = mp::List<>;
2564  using fields_t = mp::List<>;
2565 };
2566 template <> struct node_from_variant_t<86> { using type = SgAsmDwarfConstType; };
2567 
2568 // Class: AsmDwarfConstant
2570  using node = SgAsmDwarfConstant;
2571  using base = SgAsmDwarfConstruct;
2572  static constexpr char const * const name{"AsmDwarfConstant"};
2573  static constexpr unsigned long variant{87};
2574  static constexpr bool concrete{true};
2575  using subclasses_t = mp::List<>;
2576  using fields_t = mp::List<>;
2577 };
2578 template <> struct node_from_variant_t<87> { using type = SgAsmDwarfConstant; };
2579 
2580 // Class: AsmDwarfConstruct
2581 template <> struct describe_field_t<SgAsmDwarfConstruct,int,&SgAsmDwarfConstruct::p_nesting_level> {
2582  using parent = SgAsmDwarfConstruct;
2583  using field_type = int;
2584  static constexpr size_t position{0};
2585  static constexpr char const * const name{"nesting_level"};
2586  static constexpr char const * const typestr{"int"};
2587  static constexpr bool traverse{false};
2588  static constexpr auto mbr_ptr{&SgAsmDwarfConstruct::p_nesting_level};
2589  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2590  using bind = Desc<SgAsmDwarfConstruct, int SgAsmDwarfConstruct::*, &SgAsmDwarfConstruct::p_nesting_level>;
2591 };
2592 template <> struct describe_field_t<SgAsmDwarfConstruct,uint64_t,&SgAsmDwarfConstruct::p_offset> {
2593  using parent = SgAsmDwarfConstruct;
2594  using field_type = uint64_t;
2595  static constexpr size_t position{1};
2596  static constexpr char const * const name{"offset"};
2597  static constexpr char const * const typestr{"uint64_t"};
2598  static constexpr bool traverse{false};
2599  static constexpr auto mbr_ptr{&SgAsmDwarfConstruct::p_offset};
2600  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2601  using bind = Desc<SgAsmDwarfConstruct, uint64_t SgAsmDwarfConstruct::*, &SgAsmDwarfConstruct::p_offset>;
2602 };
2603 template <> struct describe_field_t<SgAsmDwarfConstruct,uint64_t,&SgAsmDwarfConstruct::p_overall_offset> {
2604  using parent = SgAsmDwarfConstruct;
2605  using field_type = uint64_t;
2606  static constexpr size_t position{2};
2607  static constexpr char const * const name{"overall_offset"};
2608  static constexpr char const * const typestr{"uint64_t"};
2609  static constexpr bool traverse{false};
2610  static constexpr auto mbr_ptr{&SgAsmDwarfConstruct::p_overall_offset};
2611  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2612  using bind = Desc<SgAsmDwarfConstruct, uint64_t SgAsmDwarfConstruct::*, &SgAsmDwarfConstruct::p_overall_offset>;
2613 };
2614 template <> struct describe_field_t<SgAsmDwarfConstruct,std::string,&SgAsmDwarfConstruct::p_name> {
2615  using parent = SgAsmDwarfConstruct;
2616  using field_type = std::string;
2617  static constexpr size_t position{3};
2618  static constexpr char const * const name{"name"};
2619  static constexpr char const * const typestr{"std::string"};
2620  static constexpr bool traverse{false};
2621  static constexpr auto mbr_ptr{&SgAsmDwarfConstruct::p_name};
2622  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2623  using bind = Desc<SgAsmDwarfConstruct, std::string SgAsmDwarfConstruct::*, &SgAsmDwarfConstruct::p_name>;
2624 };
2625 template <> struct describe_field_t<SgAsmDwarfConstruct,SgAsmDwarfLine*,&SgAsmDwarfConstruct::p_source_position> {
2626  using parent = SgAsmDwarfConstruct;
2627  using field_type = SgAsmDwarfLine*;
2628  static constexpr size_t position{4};
2629  static constexpr char const * const name{"source_position"};
2630  static constexpr char const * const typestr{"SgAsmDwarfLine*"};
2631  static constexpr bool traverse{false};
2632  static constexpr auto mbr_ptr{&SgAsmDwarfConstruct::p_source_position};
2633  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2634  using bind = Desc<SgAsmDwarfConstruct, SgAsmDwarfLine* SgAsmDwarfConstruct::*, &SgAsmDwarfConstruct::p_source_position>;
2635 };
2636 template <> struct describe_field_t<SgAsmDwarfConstruct,AstAttributeMechanism*,&SgAsmDwarfConstruct::p_attributeMechanism> {
2637  using parent = SgAsmDwarfConstruct;
2639  static constexpr size_t position{5};
2640  static constexpr char const * const name{"attributeMechanism"};
2641  static constexpr char const * const typestr{"AstAttributeMechanism*"};
2642  static constexpr bool traverse{false};
2643  static constexpr auto mbr_ptr{&SgAsmDwarfConstruct::p_attributeMechanism};
2644  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2645  using bind = Desc<SgAsmDwarfConstruct, AstAttributeMechanism* SgAsmDwarfConstruct::*, &SgAsmDwarfConstruct::p_attributeMechanism>;
2646 };
2648  using node = SgAsmDwarfConstruct;
2649  using base = SgAsmDwarfInformation;
2650  static constexpr char const * const name{"AsmDwarfConstruct"};
2651  static constexpr unsigned long variant{88};
2652  static constexpr bool concrete{false};
2653  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>;
2655 };
2656 template <> struct node_from_variant_t<88> { using type = SgAsmDwarfConstruct; };
2657 
2658 // Class: AsmDwarfConstructList
2659 template <> struct describe_field_t<SgAsmDwarfConstructList,SgAsmDwarfConstructPtrList,&SgAsmDwarfConstructList::p_list> {
2661  using field_type = SgAsmDwarfConstructPtrList;
2662  static constexpr size_t position{0};
2663  static constexpr char const * const name{"list"};
2664  static constexpr char const * const typestr{"SgAsmDwarfConstructPtrList"};
2665  static constexpr bool traverse{true};
2666  static constexpr auto mbr_ptr{&SgAsmDwarfConstructList::p_list};
2667  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2668  using bind = Desc<SgAsmDwarfConstructList, SgAsmDwarfConstructPtrList SgAsmDwarfConstructList::*, &SgAsmDwarfConstructList::p_list>;
2669 };
2671  using node = SgAsmDwarfConstructList;
2672  using base = SgAsmDwarfInformation;
2673  static constexpr char const * const name{"AsmDwarfConstructList"};
2674  static constexpr unsigned long variant{89};
2675  static constexpr bool concrete{true};
2676  using subclasses_t = mp::List<>;
2678 };
2679 template <> struct node_from_variant_t<89> { using type = SgAsmDwarfConstructList; };
2680 
2681 // Class: AsmDwarfDwarfProcedure
2684  using base = SgAsmDwarfConstruct;
2685  static constexpr char const * const name{"AsmDwarfDwarfProcedure"};
2686  static constexpr unsigned long variant{90};
2687  static constexpr bool concrete{true};
2688  using subclasses_t = mp::List<>;
2689  using fields_t = mp::List<>;
2690 };
2691 template <> struct node_from_variant_t<90> { using type = SgAsmDwarfDwarfProcedure; };
2692 
2693 // Class: AsmDwarfEntryPoint
2695  using node = SgAsmDwarfEntryPoint;
2696  using base = SgAsmDwarfConstruct;
2697  static constexpr char const * const name{"AsmDwarfEntryPoint"};
2698  static constexpr unsigned long variant{91};
2699  static constexpr bool concrete{true};
2700  using subclasses_t = mp::List<>;
2701  using fields_t = mp::List<>;
2702 };
2703 template <> struct node_from_variant_t<91> { using type = SgAsmDwarfEntryPoint; };
2704 
2705 // Class: AsmDwarfEnumerationType
2706 template <> struct describe_field_t<SgAsmDwarfEnumerationType,SgAsmDwarfConstructList*,&SgAsmDwarfEnumerationType::p_body> {
2709  static constexpr size_t position{0};
2710  static constexpr char const * const name{"body"};
2711  static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
2712  static constexpr bool traverse{true};
2713  static constexpr auto mbr_ptr{&SgAsmDwarfEnumerationType::p_body};
2714  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2715  using bind = Desc<SgAsmDwarfEnumerationType, SgAsmDwarfConstructList* SgAsmDwarfEnumerationType::*, &SgAsmDwarfEnumerationType::p_body>;
2716 };
2719  using base = SgAsmDwarfConstruct;
2720  static constexpr char const * const name{"AsmDwarfEnumerationType"};
2721  static constexpr unsigned long variant{92};
2722  static constexpr bool concrete{true};
2723  using subclasses_t = mp::List<>;
2725 };
2726 template <> struct node_from_variant_t<92> { using type = SgAsmDwarfEnumerationType; };
2727 
2728 // Class: AsmDwarfEnumerator
2730  using node = SgAsmDwarfEnumerator;
2731  using base = SgAsmDwarfConstruct;
2732  static constexpr char const * const name{"AsmDwarfEnumerator"};
2733  static constexpr unsigned long variant{93};
2734  static constexpr bool concrete{true};
2735  using subclasses_t = mp::List<>;
2736  using fields_t = mp::List<>;
2737 };
2738 template <> struct node_from_variant_t<93> { using type = SgAsmDwarfEnumerator; };
2739 
2740 // Class: AsmDwarfFileType
2742  using node = SgAsmDwarfFileType;
2743  using base = SgAsmDwarfConstruct;
2744  static constexpr char const * const name{"AsmDwarfFileType"};
2745  static constexpr unsigned long variant{94};
2746  static constexpr bool concrete{true};
2747  using subclasses_t = mp::List<>;
2748  using fields_t = mp::List<>;
2749 };
2750 template <> struct node_from_variant_t<94> { using type = SgAsmDwarfFileType; };
2751 
2752 // Class: AsmDwarfFormalParameter
2755  using base = SgAsmDwarfConstruct;
2756  static constexpr char const * const name{"AsmDwarfFormalParameter"};
2757  static constexpr unsigned long variant{95};
2758  static constexpr bool concrete{true};
2759  using subclasses_t = mp::List<>;
2760  using fields_t = mp::List<>;
2761 };
2762 template <> struct node_from_variant_t<95> { using type = SgAsmDwarfFormalParameter; };
2763 
2764 // Class: AsmDwarfFormatLabel
2766  using node = SgAsmDwarfFormatLabel;
2767  using base = SgAsmDwarfConstruct;
2768  static constexpr char const * const name{"AsmDwarfFormatLabel"};
2769  static constexpr unsigned long variant{96};
2770  static constexpr bool concrete{true};
2771  using subclasses_t = mp::List<>;
2772  using fields_t = mp::List<>;
2773 };
2774 template <> struct node_from_variant_t<96> { using type = SgAsmDwarfFormatLabel; };
2775 
2776 // Class: AsmDwarfFriend
2777 template <> struct describe_node_t<SgAsmDwarfFriend> {
2778  using node = SgAsmDwarfFriend;
2779  using base = SgAsmDwarfConstruct;
2780  static constexpr char const * const name{"AsmDwarfFriend"};
2781  static constexpr unsigned long variant{97};
2782  static constexpr bool concrete{true};
2783  using subclasses_t = mp::List<>;
2784  using fields_t = mp::List<>;
2785 };
2786 template <> struct node_from_variant_t<97> { using type = SgAsmDwarfFriend; };
2787 
2788 // Class: AsmDwarfFunctionTemplate
2791  using base = SgAsmDwarfConstruct;
2792  static constexpr char const * const name{"AsmDwarfFunctionTemplate"};
2793  static constexpr unsigned long variant{98};
2794  static constexpr bool concrete{true};
2795  using subclasses_t = mp::List<>;
2796  using fields_t = mp::List<>;
2797 };
2798 template <> struct node_from_variant_t<98> { using type = SgAsmDwarfFunctionTemplate; };
2799 
2800 // Class: AsmDwarfImportedDeclaration
2803  using base = SgAsmDwarfConstruct;
2804  static constexpr char const * const name{"AsmDwarfImportedDeclaration"};
2805  static constexpr unsigned long variant{99};
2806  static constexpr bool concrete{true};
2807  using subclasses_t = mp::List<>;
2808  using fields_t = mp::List<>;
2809 };
2810 template <> struct node_from_variant_t<99> { using type = SgAsmDwarfImportedDeclaration; };
2811 
2812 // Class: AsmDwarfImportedModule
2815  using base = SgAsmDwarfConstruct;
2816  static constexpr char const * const name{"AsmDwarfImportedModule"};
2817  static constexpr unsigned long variant{100};
2818  static constexpr bool concrete{true};
2819  using subclasses_t = mp::List<>;
2820  using fields_t = mp::List<>;
2821 };
2822 template <> struct node_from_variant_t<100> { using type = SgAsmDwarfImportedModule; };
2823 
2824 // Class: AsmDwarfImportedUnit
2826  using node = SgAsmDwarfImportedUnit;
2827  using base = SgAsmDwarfConstruct;
2828  static constexpr char const * const name{"AsmDwarfImportedUnit"};
2829  static constexpr unsigned long variant{101};
2830  static constexpr bool concrete{true};
2831  using subclasses_t = mp::List<>;
2832  using fields_t = mp::List<>;
2833 };
2834 template <> struct node_from_variant_t<101> { using type = SgAsmDwarfImportedUnit; };
2835 
2836 // Class: AsmDwarfInformation
2838  using node = SgAsmDwarfInformation;
2840  static constexpr char const * const name{"AsmDwarfInformation"};
2841  static constexpr unsigned long variant{102};
2842  static constexpr bool concrete{false};
2844  using fields_t = mp::List<>;
2845 };
2846 template <> struct node_from_variant_t<102> { using type = SgAsmDwarfInformation; };
2847 
2848 // Class: AsmDwarfInheritance
2850  using node = SgAsmDwarfInheritance;
2851  using base = SgAsmDwarfConstruct;
2852  static constexpr char const * const name{"AsmDwarfInheritance"};
2853  static constexpr unsigned long variant{103};
2854  static constexpr bool concrete{true};
2855  using subclasses_t = mp::List<>;
2856  using fields_t = mp::List<>;
2857 };
2858 template <> struct node_from_variant_t<103> { using type = SgAsmDwarfInheritance; };
2859 
2860 // Class: AsmDwarfInlinedSubroutine
2861 template <> struct describe_field_t<SgAsmDwarfInlinedSubroutine,SgAsmDwarfConstructList*,&SgAsmDwarfInlinedSubroutine::p_body> {
2864  static constexpr size_t position{0};
2865  static constexpr char const * const name{"body"};
2866  static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
2867  static constexpr bool traverse{true};
2868  static constexpr auto mbr_ptr{&SgAsmDwarfInlinedSubroutine::p_body};
2869  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2870  using bind = Desc<SgAsmDwarfInlinedSubroutine, SgAsmDwarfConstructList* SgAsmDwarfInlinedSubroutine::*, &SgAsmDwarfInlinedSubroutine::p_body>;
2871 };
2874  using base = SgAsmDwarfConstruct;
2875  static constexpr char const * const name{"AsmDwarfInlinedSubroutine"};
2876  static constexpr unsigned long variant{104};
2877  static constexpr bool concrete{true};
2878  using subclasses_t = mp::List<>;
2880 };
2881 template <> struct node_from_variant_t<104> { using type = SgAsmDwarfInlinedSubroutine; };
2882 
2883 // Class: AsmDwarfInterfaceType
2885  using node = SgAsmDwarfInterfaceType;
2886  using base = SgAsmDwarfConstruct;
2887  static constexpr char const * const name{"AsmDwarfInterfaceType"};
2888  static constexpr unsigned long variant{105};
2889  static constexpr bool concrete{true};
2890  using subclasses_t = mp::List<>;
2891  using fields_t = mp::List<>;
2892 };
2893 template <> struct node_from_variant_t<105> { using type = SgAsmDwarfInterfaceType; };
2894 
2895 // Class: AsmDwarfLabel
2896 template <> struct describe_node_t<SgAsmDwarfLabel> {
2897  using node = SgAsmDwarfLabel;
2898  using base = SgAsmDwarfConstruct;
2899  static constexpr char const * const name{"AsmDwarfLabel"};
2900  static constexpr unsigned long variant{106};
2901  static constexpr bool concrete{true};
2902  using subclasses_t = mp::List<>;
2903  using fields_t = mp::List<>;
2904 };
2905 template <> struct node_from_variant_t<106> { using type = SgAsmDwarfLabel; };
2906 
2907 // Class: AsmDwarfLexicalBlock
2908 template <> struct describe_field_t<SgAsmDwarfLexicalBlock,SgAsmDwarfConstructList*,&SgAsmDwarfLexicalBlock::p_body> {
2911  static constexpr size_t position{0};
2912  static constexpr char const * const name{"body"};
2913  static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
2914  static constexpr bool traverse{true};
2915  static constexpr auto mbr_ptr{&SgAsmDwarfLexicalBlock::p_body};
2916  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2917  using bind = Desc<SgAsmDwarfLexicalBlock, SgAsmDwarfConstructList* SgAsmDwarfLexicalBlock::*, &SgAsmDwarfLexicalBlock::p_body>;
2918 };
2920  using node = SgAsmDwarfLexicalBlock;
2921  using base = SgAsmDwarfConstruct;
2922  static constexpr char const * const name{"AsmDwarfLexicalBlock"};
2923  static constexpr unsigned long variant{107};
2924  static constexpr bool concrete{true};
2925  using subclasses_t = mp::List<>;
2927 };
2928 template <> struct node_from_variant_t<107> { using type = SgAsmDwarfLexicalBlock; };
2929 
2930 // Class: AsmDwarfLine
2931 template <> struct describe_field_t<SgAsmDwarfLine,uint64_t,&SgAsmDwarfLine::p_address> {
2932  using parent = SgAsmDwarfLine;
2933  using field_type = uint64_t;
2934  static constexpr size_t position{0};
2935  static constexpr char const * const name{"address"};
2936  static constexpr char const * const typestr{"uint64_t"};
2937  static constexpr bool traverse{false};
2938  static constexpr auto mbr_ptr{&SgAsmDwarfLine::p_address};
2939  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2940  using bind = Desc<SgAsmDwarfLine, uint64_t SgAsmDwarfLine::*, &SgAsmDwarfLine::p_address>;
2941 };
2942 template <> struct describe_field_t<SgAsmDwarfLine,int,&SgAsmDwarfLine::p_file_id> {
2943  using parent = SgAsmDwarfLine;
2944  using field_type = int;
2945  static constexpr size_t position{1};
2946  static constexpr char const * const name{"file_id"};
2947  static constexpr char const * const typestr{"int"};
2948  static constexpr bool traverse{false};
2949  static constexpr auto mbr_ptr{&SgAsmDwarfLine::p_file_id};
2950  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2951  using bind = Desc<SgAsmDwarfLine, int SgAsmDwarfLine::*, &SgAsmDwarfLine::p_file_id>;
2952 };
2953 template <> struct describe_field_t<SgAsmDwarfLine,int,&SgAsmDwarfLine::p_line> {
2954  using parent = SgAsmDwarfLine;
2955  using field_type = int;
2956  static constexpr size_t position{2};
2957  static constexpr char const * const name{"line"};
2958  static constexpr char const * const typestr{"int"};
2959  static constexpr bool traverse{false};
2960  static constexpr auto mbr_ptr{&SgAsmDwarfLine::p_line};
2961  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2962  using bind = Desc<SgAsmDwarfLine, int SgAsmDwarfLine::*, &SgAsmDwarfLine::p_line>;
2963 };
2964 template <> struct describe_field_t<SgAsmDwarfLine,int,&SgAsmDwarfLine::p_column> {
2965  using parent = SgAsmDwarfLine;
2966  using field_type = int;
2967  static constexpr size_t position{3};
2968  static constexpr char const * const name{"column"};
2969  static constexpr char const * const typestr{"int"};
2970  static constexpr bool traverse{false};
2971  static constexpr auto mbr_ptr{&SgAsmDwarfLine::p_column};
2972  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2973  using bind = Desc<SgAsmDwarfLine, int SgAsmDwarfLine::*, &SgAsmDwarfLine::p_column>;
2974 };
2975 template <> struct describe_node_t<SgAsmDwarfLine> {
2976  using node = SgAsmDwarfLine;
2977  using base = SgAsmDwarfInformation;
2978  static constexpr char const * const name{"AsmDwarfLine"};
2979  static constexpr unsigned long variant{108};
2980  static constexpr bool concrete{true};
2981  using subclasses_t = mp::List<>;
2983 };
2984 template <> struct node_from_variant_t<108> { using type = SgAsmDwarfLine; };
2985 
2986 // Class: AsmDwarfLineList
2987 template <> struct describe_field_t<SgAsmDwarfLineList,SgAsmDwarfLinePtrList,&SgAsmDwarfLineList::p_line_list> {
2988  using parent = SgAsmDwarfLineList;
2989  using field_type = SgAsmDwarfLinePtrList;
2990  static constexpr size_t position{0};
2991  static constexpr char const * const name{"line_list"};
2992  static constexpr char const * const typestr{"SgAsmDwarfLinePtrList"};
2993  static constexpr bool traverse{true};
2994  static constexpr auto mbr_ptr{&SgAsmDwarfLineList::p_line_list};
2995  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
2996  using bind = Desc<SgAsmDwarfLineList, SgAsmDwarfLinePtrList SgAsmDwarfLineList::*, &SgAsmDwarfLineList::p_line_list>;
2997 };
2999  using node = SgAsmDwarfLineList;
3000  using base = SgAsmDwarfInformation;
3001  static constexpr char const * const name{"AsmDwarfLineList"};
3002  static constexpr unsigned long variant{109};
3003  static constexpr bool concrete{true};
3004  using subclasses_t = mp::List<>;
3006 };
3007 template <> struct node_from_variant_t<109> { using type = SgAsmDwarfLineList; };
3008 
3009 // Class: AsmDwarfMacro
3010 template <> struct describe_field_t<SgAsmDwarfMacro,std::string,&SgAsmDwarfMacro::p_macro_string> {
3011  using parent = SgAsmDwarfMacro;
3012  using field_type = std::string;
3013  static constexpr size_t position{0};
3014  static constexpr char const * const name{"macro_string"};
3015  static constexpr char const * const typestr{"std::string"};
3016  static constexpr bool traverse{false};
3017  static constexpr auto mbr_ptr{&SgAsmDwarfMacro::p_macro_string};
3018  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3019  using bind = Desc<SgAsmDwarfMacro, std::string SgAsmDwarfMacro::*, &SgAsmDwarfMacro::p_macro_string>;
3020 };
3021 template <> struct describe_node_t<SgAsmDwarfMacro> {
3022  using node = SgAsmDwarfMacro;
3023  using base = SgAsmDwarfInformation;
3024  static constexpr char const * const name{"AsmDwarfMacro"};
3025  static constexpr unsigned long variant{110};
3026  static constexpr bool concrete{true};
3027  using subclasses_t = mp::List<>;
3029 };
3030 template <> struct node_from_variant_t<110> { using type = SgAsmDwarfMacro; };
3031 
3032 // Class: AsmDwarfMacroList
3033 template <> struct describe_field_t<SgAsmDwarfMacroList,SgAsmDwarfMacroPtrList,&SgAsmDwarfMacroList::p_macro_list> {
3034  using parent = SgAsmDwarfMacroList;
3035  using field_type = SgAsmDwarfMacroPtrList;
3036  static constexpr size_t position{0};
3037  static constexpr char const * const name{"macro_list"};
3038  static constexpr char const * const typestr{"SgAsmDwarfMacroPtrList"};
3039  static constexpr bool traverse{true};
3040  static constexpr auto mbr_ptr{&SgAsmDwarfMacroList::p_macro_list};
3041  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3042  using bind = Desc<SgAsmDwarfMacroList, SgAsmDwarfMacroPtrList SgAsmDwarfMacroList::*, &SgAsmDwarfMacroList::p_macro_list>;
3043 };
3045  using node = SgAsmDwarfMacroList;
3046  using base = SgAsmDwarfInformation;
3047  static constexpr char const * const name{"AsmDwarfMacroList"};
3048  static constexpr unsigned long variant{111};
3049  static constexpr bool concrete{true};
3050  using subclasses_t = mp::List<>;
3052 };
3053 template <> struct node_from_variant_t<111> { using type = SgAsmDwarfMacroList; };
3054 
3055 // Class: AsmDwarfMember
3056 template <> struct describe_node_t<SgAsmDwarfMember> {
3057  using node = SgAsmDwarfMember;
3058  using base = SgAsmDwarfConstruct;
3059  static constexpr char const * const name{"AsmDwarfMember"};
3060  static constexpr unsigned long variant{112};
3061  static constexpr bool concrete{true};
3062  using subclasses_t = mp::List<>;
3063  using fields_t = mp::List<>;
3064 };
3065 template <> struct node_from_variant_t<112> { using type = SgAsmDwarfMember; };
3066 
3067 // Class: AsmDwarfModule
3068 template <> struct describe_node_t<SgAsmDwarfModule> {
3069  using node = SgAsmDwarfModule;
3070  using base = SgAsmDwarfConstruct;
3071  static constexpr char const * const name{"AsmDwarfModule"};
3072  static constexpr unsigned long variant{113};
3073  static constexpr bool concrete{true};
3074  using subclasses_t = mp::List<>;
3075  using fields_t = mp::List<>;
3076 };
3077 template <> struct node_from_variant_t<113> { using type = SgAsmDwarfModule; };
3078 
3079 // Class: AsmDwarfMutableType
3081  using node = SgAsmDwarfMutableType;
3082  using base = SgAsmDwarfConstruct;
3083  static constexpr char const * const name{"AsmDwarfMutableType"};
3084  static constexpr unsigned long variant{114};
3085  static constexpr bool concrete{true};
3086  using subclasses_t = mp::List<>;
3087  using fields_t = mp::List<>;
3088 };
3089 template <> struct node_from_variant_t<114> { using type = SgAsmDwarfMutableType; };
3090 
3091 // Class: AsmDwarfNamelist
3093  using node = SgAsmDwarfNamelist;
3094  using base = SgAsmDwarfConstruct;
3095  static constexpr char const * const name{"AsmDwarfNamelist"};
3096  static constexpr unsigned long variant{115};
3097  static constexpr bool concrete{true};
3098  using subclasses_t = mp::List<>;
3099  using fields_t = mp::List<>;
3100 };
3101 template <> struct node_from_variant_t<115> { using type = SgAsmDwarfNamelist; };
3102 
3103 // Class: AsmDwarfNamelistItem
3105  using node = SgAsmDwarfNamelistItem;
3106  using base = SgAsmDwarfConstruct;
3107  static constexpr char const * const name{"AsmDwarfNamelistItem"};
3108  static constexpr unsigned long variant{116};
3109  static constexpr bool concrete{true};
3110  using subclasses_t = mp::List<>;
3111  using fields_t = mp::List<>;
3112 };
3113 template <> struct node_from_variant_t<116> { using type = SgAsmDwarfNamelistItem; };
3114 
3115 // Class: AsmDwarfNamespace
3116 template <> struct describe_field_t<SgAsmDwarfNamespace,SgAsmDwarfConstructList*,&SgAsmDwarfNamespace::p_body> {
3117  using parent = SgAsmDwarfNamespace;
3119  static constexpr size_t position{0};
3120  static constexpr char const * const name{"body"};
3121  static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
3122  static constexpr bool traverse{true};
3123  static constexpr auto mbr_ptr{&SgAsmDwarfNamespace::p_body};
3124  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3125  using bind = Desc<SgAsmDwarfNamespace, SgAsmDwarfConstructList* SgAsmDwarfNamespace::*, &SgAsmDwarfNamespace::p_body>;
3126 };
3128  using node = SgAsmDwarfNamespace;
3129  using base = SgAsmDwarfConstruct;
3130  static constexpr char const * const name{"AsmDwarfNamespace"};
3131  static constexpr unsigned long variant{117};
3132  static constexpr bool concrete{true};
3133  using subclasses_t = mp::List<>;
3135 };
3136 template <> struct node_from_variant_t<117> { using type = SgAsmDwarfNamespace; };
3137 
3138 // Class: AsmDwarfPackedType
3140  using node = SgAsmDwarfPackedType;
3141  using base = SgAsmDwarfConstruct;
3142  static constexpr char const * const name{"AsmDwarfPackedType"};
3143  static constexpr unsigned long variant{118};
3144  static constexpr bool concrete{true};
3145  using subclasses_t = mp::List<>;
3146  using fields_t = mp::List<>;
3147 };
3148 template <> struct node_from_variant_t<118> { using type = SgAsmDwarfPackedType; };
3149 
3150 // Class: AsmDwarfPartialUnit
3152  using node = SgAsmDwarfPartialUnit;
3153  using base = SgAsmDwarfConstruct;
3154  static constexpr char const * const name{"AsmDwarfPartialUnit"};
3155  static constexpr unsigned long variant{119};
3156  static constexpr bool concrete{true};
3157  using subclasses_t = mp::List<>;
3158  using fields_t = mp::List<>;
3159 };
3160 template <> struct node_from_variant_t<119> { using type = SgAsmDwarfPartialUnit; };
3161 
3162 // Class: AsmDwarfPointerType
3164  using node = SgAsmDwarfPointerType;
3165  using base = SgAsmDwarfConstruct;
3166  static constexpr char const * const name{"AsmDwarfPointerType"};
3167  static constexpr unsigned long variant{120};
3168  static constexpr bool concrete{true};
3169  using subclasses_t = mp::List<>;
3170  using fields_t = mp::List<>;
3171 };
3172 template <> struct node_from_variant_t<120> { using type = SgAsmDwarfPointerType; };
3173 
3174 // Class: AsmDwarfPtrToMemberType
3177  using base = SgAsmDwarfConstruct;
3178  static constexpr char const * const name{"AsmDwarfPtrToMemberType"};
3179  static constexpr unsigned long variant{121};
3180  static constexpr bool concrete{true};
3181  using subclasses_t = mp::List<>;
3182  using fields_t = mp::List<>;
3183 };
3184 template <> struct node_from_variant_t<121> { using type = SgAsmDwarfPtrToMemberType; };
3185 
3186 // Class: AsmDwarfReferenceType
3188  using node = SgAsmDwarfReferenceType;
3189  using base = SgAsmDwarfConstruct;
3190  static constexpr char const * const name{"AsmDwarfReferenceType"};
3191  static constexpr unsigned long variant{122};
3192  static constexpr bool concrete{true};
3193  using subclasses_t = mp::List<>;
3194  using fields_t = mp::List<>;
3195 };
3196 template <> struct node_from_variant_t<122> { using type = SgAsmDwarfReferenceType; };
3197 
3198 // Class: AsmDwarfRestrictType
3200  using node = SgAsmDwarfRestrictType;
3201  using base = SgAsmDwarfConstruct;
3202  static constexpr char const * const name{"AsmDwarfRestrictType"};
3203  static constexpr unsigned long variant{123};
3204  static constexpr bool concrete{true};
3205  using subclasses_t = mp::List<>;
3206  using fields_t = mp::List<>;
3207 };
3208 template <> struct node_from_variant_t<123> { using type = SgAsmDwarfRestrictType; };
3209 
3210 // Class: AsmDwarfSetType
3211 template <> struct describe_node_t<SgAsmDwarfSetType> {
3212  using node = SgAsmDwarfSetType;
3213  using base = SgAsmDwarfConstruct;
3214  static constexpr char const * const name{"AsmDwarfSetType"};
3215  static constexpr unsigned long variant{124};
3216  static constexpr bool concrete{true};
3217  using subclasses_t = mp::List<>;
3218  using fields_t = mp::List<>;
3219 };
3220 template <> struct node_from_variant_t<124> { using type = SgAsmDwarfSetType; };
3221 
3222 // Class: AsmDwarfSharedType
3224  using node = SgAsmDwarfSharedType;
3225  using base = SgAsmDwarfConstruct;
3226  static constexpr char const * const name{"AsmDwarfSharedType"};
3227  static constexpr unsigned long variant{125};
3228  static constexpr bool concrete{true};
3229  using subclasses_t = mp::List<>;
3230  using fields_t = mp::List<>;
3231 };
3232 template <> struct node_from_variant_t<125> { using type = SgAsmDwarfSharedType; };
3233 
3234 // Class: AsmDwarfStringType
3236  using node = SgAsmDwarfStringType;
3237  using base = SgAsmDwarfConstruct;
3238  static constexpr char const * const name{"AsmDwarfStringType"};
3239  static constexpr unsigned long variant{126};
3240  static constexpr bool concrete{true};
3241  using subclasses_t = mp::List<>;
3242  using fields_t = mp::List<>;
3243 };
3244 template <> struct node_from_variant_t<126> { using type = SgAsmDwarfStringType; };
3245 
3246 // Class: AsmDwarfStructureType
3247 template <> struct describe_field_t<SgAsmDwarfStructureType,SgAsmDwarfConstructList*,&SgAsmDwarfStructureType::p_body> {
3250  static constexpr size_t position{0};
3251  static constexpr char const * const name{"body"};
3252  static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
3253  static constexpr bool traverse{true};
3254  static constexpr auto mbr_ptr{&SgAsmDwarfStructureType::p_body};
3255  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3256  using bind = Desc<SgAsmDwarfStructureType, SgAsmDwarfConstructList* SgAsmDwarfStructureType::*, &SgAsmDwarfStructureType::p_body>;
3257 };
3259  using node = SgAsmDwarfStructureType;
3260  using base = SgAsmDwarfConstruct;
3261  static constexpr char const * const name{"AsmDwarfStructureType"};
3262  static constexpr unsigned long variant{127};
3263  static constexpr bool concrete{true};
3264  using subclasses_t = mp::List<>;
3266 };
3267 template <> struct node_from_variant_t<127> { using type = SgAsmDwarfStructureType; };
3268 
3269 // Class: AsmDwarfSubprogram
3270 template <> struct describe_field_t<SgAsmDwarfSubprogram,SgAsmDwarfConstructList*,&SgAsmDwarfSubprogram::p_body> {
3271  using parent = SgAsmDwarfSubprogram;
3273  static constexpr size_t position{0};
3274  static constexpr char const * const name{"body"};
3275  static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
3276  static constexpr bool traverse{true};
3277  static constexpr auto mbr_ptr{&SgAsmDwarfSubprogram::p_body};
3278  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3279  using bind = Desc<SgAsmDwarfSubprogram, SgAsmDwarfConstructList* SgAsmDwarfSubprogram::*, &SgAsmDwarfSubprogram::p_body>;
3280 };
3282  using node = SgAsmDwarfSubprogram;
3283  using base = SgAsmDwarfConstruct;
3284  static constexpr char const * const name{"AsmDwarfSubprogram"};
3285  static constexpr unsigned long variant{128};
3286  static constexpr bool concrete{true};
3287  using subclasses_t = mp::List<>;
3289 };
3290 template <> struct node_from_variant_t<128> { using type = SgAsmDwarfSubprogram; };
3291 
3292 // Class: AsmDwarfSubrangeType
3294  using node = SgAsmDwarfSubrangeType;
3295  using base = SgAsmDwarfConstruct;
3296  static constexpr char const * const name{"AsmDwarfSubrangeType"};
3297  static constexpr unsigned long variant{129};
3298  static constexpr bool concrete{true};
3299  using subclasses_t = mp::List<>;
3300  using fields_t = mp::List<>;
3301 };
3302 template <> struct node_from_variant_t<129> { using type = SgAsmDwarfSubrangeType; };
3303 
3304 // Class: AsmDwarfSubroutineType
3305 template <> struct describe_field_t<SgAsmDwarfSubroutineType,SgAsmDwarfConstructList*,&SgAsmDwarfSubroutineType::p_body> {
3308  static constexpr size_t position{0};
3309  static constexpr char const * const name{"body"};
3310  static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
3311  static constexpr bool traverse{true};
3312  static constexpr auto mbr_ptr{&SgAsmDwarfSubroutineType::p_body};
3313  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3314  using bind = Desc<SgAsmDwarfSubroutineType, SgAsmDwarfConstructList* SgAsmDwarfSubroutineType::*, &SgAsmDwarfSubroutineType::p_body>;
3315 };
3318  using base = SgAsmDwarfConstruct;
3319  static constexpr char const * const name{"AsmDwarfSubroutineType"};
3320  static constexpr unsigned long variant{130};
3321  static constexpr bool concrete{true};
3322  using subclasses_t = mp::List<>;
3324 };
3325 template <> struct node_from_variant_t<130> { using type = SgAsmDwarfSubroutineType; };
3326 
3327 // Class: AsmDwarfTemplateTypeParameter
3330  using base = SgAsmDwarfConstruct;
3331  static constexpr char const * const name{"AsmDwarfTemplateTypeParameter"};
3332  static constexpr unsigned long variant{131};
3333  static constexpr bool concrete{true};
3334  using subclasses_t = mp::List<>;
3335  using fields_t = mp::List<>;
3336 };
3337 template <> struct node_from_variant_t<131> { using type = SgAsmDwarfTemplateTypeParameter; };
3338 
3339 // Class: AsmDwarfTemplateValueParameter
3342  using base = SgAsmDwarfConstruct;
3343  static constexpr char const * const name{"AsmDwarfTemplateValueParameter"};
3344  static constexpr unsigned long variant{132};
3345  static constexpr bool concrete{true};
3346  using subclasses_t = mp::List<>;
3347  using fields_t = mp::List<>;
3348 };
3349 template <> struct node_from_variant_t<132> { using type = SgAsmDwarfTemplateValueParameter; };
3350 
3351 // Class: AsmDwarfThrownType
3353  using node = SgAsmDwarfThrownType;
3354  using base = SgAsmDwarfConstruct;
3355  static constexpr char const * const name{"AsmDwarfThrownType"};
3356  static constexpr unsigned long variant{133};
3357  static constexpr bool concrete{true};
3358  using subclasses_t = mp::List<>;
3359  using fields_t = mp::List<>;
3360 };
3361 template <> struct node_from_variant_t<133> { using type = SgAsmDwarfThrownType; };
3362 
3363 // Class: AsmDwarfTryBlock
3365  using node = SgAsmDwarfTryBlock;
3366  using base = SgAsmDwarfConstruct;
3367  static constexpr char const * const name{"AsmDwarfTryBlock"};
3368  static constexpr unsigned long variant{134};
3369  static constexpr bool concrete{true};
3370  using subclasses_t = mp::List<>;
3371  using fields_t = mp::List<>;
3372 };
3373 template <> struct node_from_variant_t<134> { using type = SgAsmDwarfTryBlock; };
3374 
3375 // Class: AsmDwarfTypedef
3376 template <> struct describe_node_t<SgAsmDwarfTypedef> {
3377  using node = SgAsmDwarfTypedef;
3378  using base = SgAsmDwarfConstruct;
3379  static constexpr char const * const name{"AsmDwarfTypedef"};
3380  static constexpr unsigned long variant{135};
3381  static constexpr bool concrete{true};
3382  using subclasses_t = mp::List<>;
3383  using fields_t = mp::List<>;
3384 };
3385 template <> struct node_from_variant_t<135> { using type = SgAsmDwarfTypedef; };
3386 
3387 // Class: AsmDwarfUnionType
3388 template <> struct describe_field_t<SgAsmDwarfUnionType,SgAsmDwarfConstructList*,&SgAsmDwarfUnionType::p_body> {
3389  using parent = SgAsmDwarfUnionType;
3391  static constexpr size_t position{0};
3392  static constexpr char const * const name{"body"};
3393  static constexpr char const * const typestr{"SgAsmDwarfConstructList*"};
3394  static constexpr bool traverse{true};
3395  static constexpr auto mbr_ptr{&SgAsmDwarfUnionType::p_body};
3396  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3397  using bind = Desc<SgAsmDwarfUnionType, SgAsmDwarfConstructList* SgAsmDwarfUnionType::*, &SgAsmDwarfUnionType::p_body>;
3398 };
3400  using node = SgAsmDwarfUnionType;
3401  using base = SgAsmDwarfConstruct;
3402  static constexpr char const * const name{"AsmDwarfUnionType"};
3403  static constexpr unsigned long variant{136};
3404  static constexpr bool concrete{true};
3405  using subclasses_t = mp::List<>;
3407 };
3408 template <> struct node_from_variant_t<136> { using type = SgAsmDwarfUnionType; };
3409 
3410 // Class: AsmDwarfUnknownConstruct
3413  using base = SgAsmDwarfConstruct;
3414  static constexpr char const * const name{"AsmDwarfUnknownConstruct"};
3415  static constexpr unsigned long variant{137};
3416  static constexpr bool concrete{true};
3417  using subclasses_t = mp::List<>;
3418  using fields_t = mp::List<>;
3419 };
3420 template <> struct node_from_variant_t<137> { using type = SgAsmDwarfUnknownConstruct; };
3421 
3422 // Class: AsmDwarfUnspecifiedParameters
3425  using base = SgAsmDwarfConstruct;
3426  static constexpr char const * const name{"AsmDwarfUnspecifiedParameters"};
3427  static constexpr unsigned long variant{138};
3428  static constexpr bool concrete{true};
3429  using subclasses_t = mp::List<>;
3430  using fields_t = mp::List<>;
3431 };
3432 template <> struct node_from_variant_t<138> { using type = SgAsmDwarfUnspecifiedParameters; };
3433 
3434 // Class: AsmDwarfUnspecifiedType
3437  using base = SgAsmDwarfConstruct;
3438  static constexpr char const * const name{"AsmDwarfUnspecifiedType"};
3439  static constexpr unsigned long variant{139};
3440  static constexpr bool concrete{true};
3441  using subclasses_t = mp::List<>;
3442  using fields_t = mp::List<>;
3443 };
3444 template <> struct node_from_variant_t<139> { using type = SgAsmDwarfUnspecifiedType; };
3445 
3446 // Class: AsmDwarfUpcRelaxedType
3449  using base = SgAsmDwarfConstruct;
3450  static constexpr char const * const name{"AsmDwarfUpcRelaxedType"};
3451  static constexpr unsigned long variant{140};
3452  static constexpr bool concrete{true};
3453  using subclasses_t = mp::List<>;
3454  using fields_t = mp::List<>;
3455 };
3456 template <> struct node_from_variant_t<140> { using type = SgAsmDwarfUpcRelaxedType; };
3457 
3458 // Class: AsmDwarfUpcSharedType
3460  using node = SgAsmDwarfUpcSharedType;
3461  using base = SgAsmDwarfConstruct;
3462  static constexpr char const * const name{"AsmDwarfUpcSharedType"};
3463  static constexpr unsigned long variant{141};
3464  static constexpr bool concrete{true};
3465  using subclasses_t = mp::List<>;
3466  using fields_t = mp::List<>;
3467 };
3468 template <> struct node_from_variant_t<141> { using type = SgAsmDwarfUpcSharedType; };
3469 
3470 // Class: AsmDwarfUpcStrictType
3472  using node = SgAsmDwarfUpcStrictType;
3473  using base = SgAsmDwarfConstruct;
3474  static constexpr char const * const name{"AsmDwarfUpcStrictType"};
3475  static constexpr unsigned long variant{142};
3476  static constexpr bool concrete{true};
3477  using subclasses_t = mp::List<>;
3478  using fields_t = mp::List<>;
3479 };
3480 template <> struct node_from_variant_t<142> { using type = SgAsmDwarfUpcStrictType; };
3481 
3482 // Class: AsmDwarfVariable
3484  using node = SgAsmDwarfVariable;
3485  using base = SgAsmDwarfConstruct;
3486  static constexpr char const * const name{"AsmDwarfVariable"};
3487  static constexpr unsigned long variant{143};
3488  static constexpr bool concrete{true};
3489  using subclasses_t = mp::List<>;
3490  using fields_t = mp::List<>;
3491 };
3492 template <> struct node_from_variant_t<143> { using type = SgAsmDwarfVariable; };
3493 
3494 // Class: AsmDwarfVariant
3495 template <> struct describe_node_t<SgAsmDwarfVariant> {
3496  using node = SgAsmDwarfVariant;
3497  using base = SgAsmDwarfConstruct;
3498  static constexpr char const * const name{"AsmDwarfVariant"};
3499  static constexpr unsigned long variant{144};
3500  static constexpr bool concrete{true};
3501  using subclasses_t = mp::List<>;
3502  using fields_t = mp::List<>;
3503 };
3504 template <> struct node_from_variant_t<144> { using type = SgAsmDwarfVariant; };
3505 
3506 // Class: AsmDwarfVariantPart
3508  using node = SgAsmDwarfVariantPart;
3509  using base = SgAsmDwarfConstruct;
3510  static constexpr char const * const name{"AsmDwarfVariantPart"};
3511  static constexpr unsigned long variant{145};
3512  static constexpr bool concrete{true};
3513  using subclasses_t = mp::List<>;
3514  using fields_t = mp::List<>;
3515 };
3516 template <> struct node_from_variant_t<145> { using type = SgAsmDwarfVariantPart; };
3517 
3518 // Class: AsmDwarfVolatileType
3520  using node = SgAsmDwarfVolatileType;
3521  using base = SgAsmDwarfConstruct;
3522  static constexpr char const * const name{"AsmDwarfVolatileType"};
3523  static constexpr unsigned long variant{146};
3524  static constexpr bool concrete{true};
3525  using subclasses_t = mp::List<>;
3526  using fields_t = mp::List<>;
3527 };
3528 template <> struct node_from_variant_t<146> { using type = SgAsmDwarfVolatileType; };
3529 
3530 // Class: AsmDwarfWithStmt
3532  using node = SgAsmDwarfWithStmt;
3533  using base = SgAsmDwarfConstruct;
3534  static constexpr char const * const name{"AsmDwarfWithStmt"};
3535  static constexpr unsigned long variant{147};
3536  static constexpr bool concrete{true};
3537  using subclasses_t = mp::List<>;
3538  using fields_t = mp::List<>;
3539 };
3540 template <> struct node_from_variant_t<147> { using type = SgAsmDwarfWithStmt; };
3541 
3542 // Class: AsmElfDynamicEntry
3543 template <> struct describe_field_t<SgAsmElfDynamicEntry,SgAsmElfDynamicEntry::EntryType,&SgAsmElfDynamicEntry::p_d_tag> {
3544  using parent = SgAsmElfDynamicEntry;
3545  using field_type = SgAsmElfDynamicEntry::EntryType;
3546  static constexpr size_t position{0};
3547  static constexpr char const * const name{"d_tag"};
3548  static constexpr char const * const typestr{"SgAsmElfDynamicEntry::EntryType"};
3549  static constexpr bool traverse{false};
3550  static constexpr auto mbr_ptr{&SgAsmElfDynamicEntry::p_d_tag};
3551  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3552  using bind = Desc<SgAsmElfDynamicEntry, SgAsmElfDynamicEntry::EntryType SgAsmElfDynamicEntry::*, &SgAsmElfDynamicEntry::p_d_tag>;
3553 };
3554 template <> struct describe_field_t<SgAsmElfDynamicEntry,rose_rva_t,&SgAsmElfDynamicEntry::p_d_val> {
3555  using parent = SgAsmElfDynamicEntry;
3556  using field_type = rose_rva_t;
3557  static constexpr size_t position{1};
3558  static constexpr char const * const name{"d_val"};
3559  static constexpr char const * const typestr{"rose_rva_t"};
3560  static constexpr bool traverse{false};
3561  static constexpr auto mbr_ptr{&SgAsmElfDynamicEntry::p_d_val};
3562  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3563  using bind = Desc<SgAsmElfDynamicEntry, rose_rva_t SgAsmElfDynamicEntry::*, &SgAsmElfDynamicEntry::p_d_val>;
3564 };
3565 template <> struct describe_field_t<SgAsmElfDynamicEntry,SgAsmGenericString*,&SgAsmElfDynamicEntry::p_name> {
3566  using parent = SgAsmElfDynamicEntry;
3567  using field_type = SgAsmGenericString*;
3568  static constexpr size_t position{2};
3569  static constexpr char const * const name{"name"};
3570  static constexpr char const * const typestr{"SgAsmGenericString*"};
3571  static constexpr bool traverse{true};
3572  static constexpr auto mbr_ptr{&SgAsmElfDynamicEntry::p_name};
3573  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3574  using bind = Desc<SgAsmElfDynamicEntry, SgAsmGenericString* SgAsmElfDynamicEntry::*, &SgAsmElfDynamicEntry::p_name>;
3575 };
3576 template <> struct describe_field_t<SgAsmElfDynamicEntry,SgUnsignedCharList,&SgAsmElfDynamicEntry::p_extra> {
3577  using parent = SgAsmElfDynamicEntry;
3578  using field_type = SgUnsignedCharList;
3579  static constexpr size_t position{3};
3580  static constexpr char const * const name{"extra"};
3581  static constexpr char const * const typestr{"SgUnsignedCharList"};
3582  static constexpr bool traverse{false};
3583  static constexpr auto mbr_ptr{&SgAsmElfDynamicEntry::p_extra};
3584  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3585  using bind = Desc<SgAsmElfDynamicEntry, SgUnsignedCharList SgAsmElfDynamicEntry::*, &SgAsmElfDynamicEntry::p_extra>;
3586 };
3588  using node = SgAsmElfDynamicEntry;
3590  static constexpr char const * const name{"AsmElfDynamicEntry"};
3591  static constexpr unsigned long variant{148};
3592  static constexpr bool concrete{true};
3593  using subclasses_t = mp::List<>;
3595 };
3596 template <> struct node_from_variant_t<148> { using type = SgAsmElfDynamicEntry; };
3597 
3598 // Class: AsmElfDynamicEntryList
3599 template <> struct describe_field_t<SgAsmElfDynamicEntryList,SgAsmElfDynamicEntryPtrList,&SgAsmElfDynamicEntryList::p_entries> {
3601  using field_type = SgAsmElfDynamicEntryPtrList;
3602  static constexpr size_t position{0};
3603  static constexpr char const * const name{"entries"};
3604  static constexpr char const * const typestr{"SgAsmElfDynamicEntryPtrList"};
3605  static constexpr bool traverse{false};
3606  static constexpr auto mbr_ptr{&SgAsmElfDynamicEntryList::p_entries};
3607  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3608  using bind = Desc<SgAsmElfDynamicEntryList, SgAsmElfDynamicEntryPtrList SgAsmElfDynamicEntryList::*, &SgAsmElfDynamicEntryList::p_entries>;
3609 };
3613  static constexpr char const * const name{"AsmElfDynamicEntryList"};
3614  static constexpr unsigned long variant{149};
3615  static constexpr bool concrete{true};
3616  using subclasses_t = mp::List<>;
3618 };
3619 template <> struct node_from_variant_t<149> { using type = SgAsmElfDynamicEntryList; };
3620 
3621 // Class: AsmElfDynamicSection
3622 template <> struct describe_field_t<SgAsmElfDynamicSection,SgAsmElfDynamicEntryList*,&SgAsmElfDynamicSection::p_entries> {
3625  static constexpr size_t position{0};
3626  static constexpr char const * const name{"entries"};
3627  static constexpr char const * const typestr{"SgAsmElfDynamicEntryList*"};
3628  static constexpr bool traverse{true};
3629  static constexpr auto mbr_ptr{&SgAsmElfDynamicSection::p_entries};
3630  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3631  using bind = Desc<SgAsmElfDynamicSection, SgAsmElfDynamicEntryList* SgAsmElfDynamicSection::*, &SgAsmElfDynamicSection::p_entries>;
3632 };
3634  using node = SgAsmElfDynamicSection;
3635  using base = SgAsmElfSection;
3636  static constexpr char const * const name{"AsmElfDynamicSection"};
3637  static constexpr unsigned long variant{150};
3638  static constexpr bool concrete{true};
3639  using subclasses_t = mp::List<>;
3641 };
3642 template <> struct node_from_variant_t<150> { using type = SgAsmElfDynamicSection; };
3643 
3644 // Class: AsmElfEHFrameEntryCI
3645 template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,int,&SgAsmElfEHFrameEntryCI::p_version> {
3647  using field_type = int;
3648  static constexpr size_t position{0};
3649  static constexpr char const * const name{"version"};
3650  static constexpr char const * const typestr{"int"};
3651  static constexpr bool traverse{false};
3652  static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_version};
3653  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3654  using bind = Desc<SgAsmElfEHFrameEntryCI, int SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_version>;
3655 };
3656 template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,std::string,&SgAsmElfEHFrameEntryCI::p_augmentation_string> {
3658  using field_type = std::string;
3659  static constexpr size_t position{1};
3660  static constexpr char const * const name{"augmentation_string"};
3661  static constexpr char const * const typestr{"std::string"};
3662  static constexpr bool traverse{false};
3663  static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_augmentation_string};
3664  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3665  using bind = Desc<SgAsmElfEHFrameEntryCI, std::string SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_augmentation_string>;
3666 };
3667 template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,uint64_t,&SgAsmElfEHFrameEntryCI::p_eh_data> {
3669  using field_type = uint64_t;
3670  static constexpr size_t position{2};
3671  static constexpr char const * const name{"eh_data"};
3672  static constexpr char const * const typestr{"uint64_t"};
3673  static constexpr bool traverse{false};
3674  static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_eh_data};
3675  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3676  using bind = Desc<SgAsmElfEHFrameEntryCI, uint64_t SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_eh_data>;
3677 };
3678 template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,uint64_t,&SgAsmElfEHFrameEntryCI::p_code_alignment_factor> {
3680  using field_type = uint64_t;
3681  static constexpr size_t position{3};
3682  static constexpr char const * const name{"code_alignment_factor"};
3683  static constexpr char const * const typestr{"uint64_t"};
3684  static constexpr bool traverse{false};
3685  static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_code_alignment_factor};
3686  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3687  using bind = Desc<SgAsmElfEHFrameEntryCI, uint64_t SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_code_alignment_factor>;
3688 };
3689 template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,int64_t,&SgAsmElfEHFrameEntryCI::p_data_alignment_factor> {
3691  using field_type = int64_t;
3692  static constexpr size_t position{4};
3693  static constexpr char const * const name{"data_alignment_factor"};
3694  static constexpr char const * const typestr{"int64_t"};
3695  static constexpr bool traverse{false};
3696  static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_data_alignment_factor};
3697  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3698  using bind = Desc<SgAsmElfEHFrameEntryCI, int64_t SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_data_alignment_factor>;
3699 };
3700 template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,uint64_t,&SgAsmElfEHFrameEntryCI::p_augmentation_data_length> {
3702  using field_type = uint64_t;
3703  static constexpr size_t position{5};
3704  static constexpr char const * const name{"augmentation_data_length"};
3705  static constexpr char const * const typestr{"uint64_t"};
3706  static constexpr bool traverse{false};
3707  static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_augmentation_data_length};
3708  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3709  using bind = Desc<SgAsmElfEHFrameEntryCI, uint64_t SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_augmentation_data_length>;
3710 };
3711 template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,int,&SgAsmElfEHFrameEntryCI::p_lsda_encoding> {
3713  using field_type = int;
3714  static constexpr size_t position{6};
3715  static constexpr char const * const name{"lsda_encoding"};
3716  static constexpr char const * const typestr{"int"};
3717  static constexpr bool traverse{false};
3718  static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_lsda_encoding};
3719  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3720  using bind = Desc<SgAsmElfEHFrameEntryCI, int SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_lsda_encoding>;
3721 };
3722 template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,int,&SgAsmElfEHFrameEntryCI::p_prh_encoding> {
3724  using field_type = int;
3725  static constexpr size_t position{7};
3726  static constexpr char const * const name{"prh_encoding"};
3727  static constexpr char const * const typestr{"int"};
3728  static constexpr bool traverse{false};
3729  static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_prh_encoding};
3730  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3731  using bind = Desc<SgAsmElfEHFrameEntryCI, int SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_prh_encoding>;
3732 };
3733 template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,unsigned,&SgAsmElfEHFrameEntryCI::p_prh_arg> {
3735  using field_type = unsigned;
3736  static constexpr size_t position{8};
3737  static constexpr char const * const name{"prh_arg"};
3738  static constexpr char const * const typestr{"unsigned"};
3739  static constexpr bool traverse{false};
3740  static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_prh_arg};
3741  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3742  using bind = Desc<SgAsmElfEHFrameEntryCI, unsigned SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_prh_arg>;
3743 };
3744 template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,rose_addr_t,&SgAsmElfEHFrameEntryCI::p_prh_addr> {
3746  using field_type = rose_addr_t;
3747  static constexpr size_t position{9};
3748  static constexpr char const * const name{"prh_addr"};
3749  static constexpr char const * const typestr{"rose_addr_t"};
3750  static constexpr bool traverse{false};
3751  static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_prh_addr};
3752  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3753  using bind = Desc<SgAsmElfEHFrameEntryCI, rose_addr_t SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_prh_addr>;
3754 };
3755 template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,int,&SgAsmElfEHFrameEntryCI::p_addr_encoding> {
3757  using field_type = int;
3758  static constexpr size_t position{10};
3759  static constexpr char const * const name{"addr_encoding"};
3760  static constexpr char const * const typestr{"int"};
3761  static constexpr bool traverse{false};
3762  static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_addr_encoding};
3763  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3764  using bind = Desc<SgAsmElfEHFrameEntryCI, int SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_addr_encoding>;
3765 };
3766 template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,bool,&SgAsmElfEHFrameEntryCI::p_sig_frame> {
3768  using field_type = bool;
3769  static constexpr size_t position{11};
3770  static constexpr char const * const name{"sig_frame"};
3771  static constexpr char const * const typestr{"bool"};
3772  static constexpr bool traverse{false};
3773  static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_sig_frame};
3774  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3775  using bind = Desc<SgAsmElfEHFrameEntryCI, bool SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_sig_frame>;
3776 };
3777 template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,SgUnsignedCharList,&SgAsmElfEHFrameEntryCI::p_instructions> {
3779  using field_type = SgUnsignedCharList;
3780  static constexpr size_t position{12};
3781  static constexpr char const * const name{"instructions"};
3782  static constexpr char const * const typestr{"SgUnsignedCharList"};
3783  static constexpr bool traverse{false};
3784  static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_instructions};
3785  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3786  using bind = Desc<SgAsmElfEHFrameEntryCI, SgUnsignedCharList SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_instructions>;
3787 };
3788 template <> struct describe_field_t<SgAsmElfEHFrameEntryCI,SgAsmElfEHFrameEntryFDList*,&SgAsmElfEHFrameEntryCI::p_fd_entries> {
3790  using field_type = SgAsmElfEHFrameEntryFDList*;
3791  static constexpr size_t position{13};
3792  static constexpr char const * const name{"fd_entries"};
3793  static constexpr char const * const typestr{"SgAsmElfEHFrameEntryFDList*"};
3794  static constexpr bool traverse{true};
3795  static constexpr auto mbr_ptr{&SgAsmElfEHFrameEntryCI::p_fd_entries};
3796  template <template <typename NodeT, typename FieldT, FieldT fld_ptr> class Desc>
3797  using bind = Desc<SgAsmElfEHFrameEntryCI, SgAsmElfEHFrameEntryFDList* SgAsmElfEHFrameEntryCI::*, &SgAsmElfEHFrameEntryCI::p_fd_entries>;
3798 };
3800  using node = SgAsmElfEHFrameEntryCI;
3802  static constexpr char const * const name{"AsmElfEHFrameEntryCI"};
3803  static constexpr unsigned long variant{151};
3804  static constexpr bool concrete{true};
3805  using subclasses_t = mp::List<>;
3807 };
3808 template <> struct node_from_variant_t<151> { using type = SgAsmElfEHFrameEntryCI; };
3809 
3810 // Class: AsmElfEHFrameEntryCIList
3811 template <> struct describe_field_t<SgAsmElfEHFrameEntryCIList,SgAsmElfEHFrameEntryCIPtrList,&SgAsmElfEHFrameEntryCIList::p_entries> {
3813  using field_type = SgAsmElfEHFrameEntryCIPtrList;
3814  static constexpr size_t position{0};
3815  static constexpr char const * const name{"entries"};
3816