1 // Copyright (c) 2008 Roberto Raggi <roberto.raggi@gmail.com>
2 //
3 // Permission is hereby granted, free of charge, to any person obtaining a copy
4 // of this software and associated documentation files (the "Software"), to deal
5 // in the Software without restriction, including without limitation the rights
6 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7 // copies of the Software, and to permit persons to whom the Software is
8 // furnished to do so, subject to the following conditions:
9 //
10 // The above copyright notice and this permission notice shall be included in
11 // all copies or substantial portions of the Software.
12 //
13 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19 // THE SOFTWARE.
20
21 //
22 // W A R N I N G
23 // -------------
24 //
25 // This file is automatically generated by "cplusplus-update-frontend".
26 // Changes will be lost.
27 //
28
29 #include "AST.h"
30 #include "MemoryPool.h"
31
32 using namespace CPlusPlus;
33
clone(MemoryPool * pool) const34 ObjCSelectorArgumentAST *ObjCSelectorArgumentAST::clone(MemoryPool *pool) const
35 {
36 ObjCSelectorArgumentAST *ast = new (pool) ObjCSelectorArgumentAST;
37 ast->name_token = name_token;
38 ast->colon_token = colon_token;
39 return ast;
40 }
41
clone(MemoryPool * pool) const42 ObjCSelectorAST *ObjCSelectorAST::clone(MemoryPool *pool) const
43 {
44 ObjCSelectorAST *ast = new (pool) ObjCSelectorAST;
45 for (ObjCSelectorArgumentListAST *iter = selector_argument_list, **ast_iter = &ast->selector_argument_list;
46 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
47 *ast_iter = new (pool) ObjCSelectorArgumentListAST((iter->value) ? iter->value->clone(pool) : nullptr);
48 return ast;
49 }
50
clone(MemoryPool * pool) const51 SimpleSpecifierAST *SimpleSpecifierAST::clone(MemoryPool *pool) const
52 {
53 SimpleSpecifierAST *ast = new (pool) SimpleSpecifierAST;
54 ast->specifier_token = specifier_token;
55 return ast;
56 }
57
clone(MemoryPool * pool) const58 AlignmentSpecifierAST *AlignmentSpecifierAST::clone(MemoryPool *pool) const
59 {
60 AlignmentSpecifierAST *ast = new (pool) AlignmentSpecifierAST;
61 ast->align_token = align_token;
62 ast->lparen_token = lparen_token;
63 if (typeIdExprOrAlignmentExpr)
64 ast->typeIdExprOrAlignmentExpr = typeIdExprOrAlignmentExpr->clone(pool);
65 ast->ellipses_token = ellipses_token;
66 ast->rparen_token = rparen_token;
67 return ast;
68 }
69
clone(MemoryPool * pool) const70 GnuAttributeSpecifierAST *GnuAttributeSpecifierAST::clone(MemoryPool *pool) const
71 {
72 GnuAttributeSpecifierAST *ast = new (pool) GnuAttributeSpecifierAST;
73 ast->attribute_token = attribute_token;
74 ast->first_lparen_token = first_lparen_token;
75 ast->second_lparen_token = second_lparen_token;
76 for (GnuAttributeListAST *iter = attribute_list, **ast_iter = &ast->attribute_list;
77 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
78 *ast_iter = new (pool) GnuAttributeListAST((iter->value) ? iter->value->clone(pool) : nullptr);
79 ast->first_rparen_token = first_rparen_token;
80 ast->second_rparen_token = second_rparen_token;
81 return ast;
82 }
83
clone(MemoryPool * pool) const84 MsvcDeclspecSpecifierAST *MsvcDeclspecSpecifierAST::clone(MemoryPool *pool) const
85 {
86 MsvcDeclspecSpecifierAST *ast = new (pool) MsvcDeclspecSpecifierAST;
87 ast->attribute_token = attribute_token;
88 ast->lparen_token = lparen_token;
89 for (GnuAttributeListAST *iter = attribute_list, **ast_iter = &ast->attribute_list;
90 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
91 *ast_iter = new (pool) GnuAttributeListAST((iter->value) ? iter->value->clone(pool) : nullptr);
92 ast->rparen_token = rparen_token;
93 return ast;
94 }
95
clone(MemoryPool * pool) const96 StdAttributeSpecifierAST *StdAttributeSpecifierAST::clone(MemoryPool *pool) const
97 {
98 StdAttributeSpecifierAST *ast = new (pool) StdAttributeSpecifierAST;
99 ast->first_lbracket_token = first_lbracket_token;
100 ast->second_lbracket_token = second_lbracket_token;
101 for (GnuAttributeListAST *iter = attribute_list, **ast_iter = &ast->attribute_list;
102 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
103 *ast_iter = new (pool) GnuAttributeListAST((iter->value) ? iter->value->clone(pool) : nullptr);
104 ast->first_rbracket_token = first_rbracket_token;
105 ast->second_rbracket_token = second_rbracket_token;
106 return ast;
107 }
108
clone(MemoryPool * pool) const109 GnuAttributeAST *GnuAttributeAST::clone(MemoryPool *pool) const
110 {
111 GnuAttributeAST *ast = new (pool) GnuAttributeAST;
112 ast->identifier_token = identifier_token;
113 ast->lparen_token = lparen_token;
114 ast->tag_token = tag_token;
115 for (ExpressionListAST *iter = expression_list, **ast_iter = &ast->expression_list;
116 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
117 *ast_iter = new (pool) ExpressionListAST((iter->value) ? iter->value->clone(pool) : nullptr);
118 ast->rparen_token = rparen_token;
119 return ast;
120 }
121
clone(MemoryPool * pool) const122 TypeofSpecifierAST *TypeofSpecifierAST::clone(MemoryPool *pool) const
123 {
124 TypeofSpecifierAST *ast = new (pool) TypeofSpecifierAST;
125 ast->typeof_token = typeof_token;
126 ast->lparen_token = lparen_token;
127 if (expression)
128 ast->expression = expression->clone(pool);
129 ast->rparen_token = rparen_token;
130 return ast;
131 }
132
clone(MemoryPool * pool) const133 DecltypeSpecifierAST *DecltypeSpecifierAST::clone(MemoryPool *pool) const
134 {
135 DecltypeSpecifierAST *ast = new (pool) DecltypeSpecifierAST;
136 ast->decltype_token = decltype_token;
137 ast->lparen_token = lparen_token;
138 if (expression)
139 ast->expression = expression->clone(pool);
140 ast->rparen_token = rparen_token;
141 return ast;
142 }
143
clone(MemoryPool * pool) const144 DeclaratorAST *DeclaratorAST::clone(MemoryPool *pool) const
145 {
146 DeclaratorAST *ast = new (pool) DeclaratorAST;
147 for (SpecifierListAST *iter = attribute_list, **ast_iter = &ast->attribute_list;
148 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
149 *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : nullptr);
150 for (PtrOperatorListAST *iter = ptr_operator_list, **ast_iter = &ast->ptr_operator_list;
151 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
152 *ast_iter = new (pool) PtrOperatorListAST((iter->value) ? iter->value->clone(pool) : nullptr);
153 if (core_declarator)
154 ast->core_declarator = core_declarator->clone(pool);
155 for (PostfixDeclaratorListAST *iter = postfix_declarator_list, **ast_iter = &ast->postfix_declarator_list;
156 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
157 *ast_iter = new (pool) PostfixDeclaratorListAST((iter->value) ? iter->value->clone(pool) : nullptr);
158 for (SpecifierListAST *iter = post_attribute_list, **ast_iter = &ast->post_attribute_list;
159 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
160 *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : nullptr);
161 ast->equal_token = equal_token;
162 if (initializer)
163 ast->initializer = initializer->clone(pool);
164 return ast;
165 }
166
clone(MemoryPool * pool) const167 SimpleDeclarationAST *SimpleDeclarationAST::clone(MemoryPool *pool) const
168 {
169 SimpleDeclarationAST *ast = new (pool) SimpleDeclarationAST;
170 ast->qt_invokable_token = qt_invokable_token;
171 for (SpecifierListAST *iter = decl_specifier_list, **ast_iter = &ast->decl_specifier_list;
172 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
173 *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : nullptr);
174 for (DeclaratorListAST *iter = declarator_list, **ast_iter = &ast->declarator_list;
175 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
176 *ast_iter = new (pool) DeclaratorListAST((iter->value) ? iter->value->clone(pool) : nullptr);
177 ast->semicolon_token = semicolon_token;
178 return ast;
179 }
180
clone(MemoryPool * pool) const181 EmptyDeclarationAST *EmptyDeclarationAST::clone(MemoryPool *pool) const
182 {
183 EmptyDeclarationAST *ast = new (pool) EmptyDeclarationAST;
184 ast->semicolon_token = semicolon_token;
185 return ast;
186 }
187
clone(MemoryPool * pool) const188 AccessDeclarationAST *AccessDeclarationAST::clone(MemoryPool *pool) const
189 {
190 AccessDeclarationAST *ast = new (pool) AccessDeclarationAST;
191 ast->access_specifier_token = access_specifier_token;
192 ast->slots_token = slots_token;
193 ast->colon_token = colon_token;
194 return ast;
195 }
196
clone(MemoryPool * pool) const197 QtObjectTagAST *QtObjectTagAST::clone(MemoryPool *pool) const
198 {
199 QtObjectTagAST *ast = new (pool) QtObjectTagAST;
200 ast->q_object_token = q_object_token;
201 return ast;
202 }
203
clone(MemoryPool * pool) const204 QtPrivateSlotAST *QtPrivateSlotAST::clone(MemoryPool *pool) const
205 {
206 QtPrivateSlotAST *ast = new (pool) QtPrivateSlotAST;
207 ast->q_private_slot_token = q_private_slot_token;
208 ast->lparen_token = lparen_token;
209 ast->dptr_token = dptr_token;
210 ast->dptr_lparen_token = dptr_lparen_token;
211 ast->dptr_rparen_token = dptr_rparen_token;
212 ast->comma_token = comma_token;
213 for (SpecifierListAST *iter = type_specifier_list, **ast_iter = &ast->type_specifier_list;
214 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
215 *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : nullptr);
216 if (declarator)
217 ast->declarator = declarator->clone(pool);
218 ast->rparen_token = rparen_token;
219 return ast;
220 }
221
clone(MemoryPool * pool) const222 QtPropertyDeclarationItemAST *QtPropertyDeclarationItemAST::clone(MemoryPool *pool) const
223 {
224 QtPropertyDeclarationItemAST *ast = new (pool) QtPropertyDeclarationItemAST;
225 ast->item_name_token = item_name_token;
226 if (expression)
227 ast->expression = expression->clone(pool);
228 return ast;
229 }
230
clone(MemoryPool * pool) const231 QtPropertyDeclarationAST *QtPropertyDeclarationAST::clone(MemoryPool *pool) const
232 {
233 QtPropertyDeclarationAST *ast = new (pool) QtPropertyDeclarationAST;
234 ast->property_specifier_token = property_specifier_token;
235 ast->lparen_token = lparen_token;
236 if (expression)
237 ast->expression = expression->clone(pool);
238 ast->comma_token = comma_token;
239 if (type_id)
240 ast->type_id = type_id->clone(pool);
241 if (property_name)
242 ast->property_name = property_name->clone(pool);
243 for (QtPropertyDeclarationItemListAST *iter = property_declaration_item_list, **ast_iter = &ast->property_declaration_item_list;
244 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
245 *ast_iter = new (pool) QtPropertyDeclarationItemListAST((iter->value) ? iter->value->clone(pool) : nullptr);
246 ast->rparen_token = rparen_token;
247 return ast;
248 }
249
clone(MemoryPool * pool) const250 QtEnumDeclarationAST *QtEnumDeclarationAST::clone(MemoryPool *pool) const
251 {
252 QtEnumDeclarationAST *ast = new (pool) QtEnumDeclarationAST;
253 ast->enum_specifier_token = enum_specifier_token;
254 ast->lparen_token = lparen_token;
255 for (NameListAST *iter = enumerator_list, **ast_iter = &ast->enumerator_list;
256 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
257 *ast_iter = new (pool) NameListAST((iter->value) ? iter->value->clone(pool) : nullptr);
258 ast->rparen_token = rparen_token;
259 return ast;
260 }
261
clone(MemoryPool * pool) const262 QtFlagsDeclarationAST *QtFlagsDeclarationAST::clone(MemoryPool *pool) const
263 {
264 QtFlagsDeclarationAST *ast = new (pool) QtFlagsDeclarationAST;
265 ast->flags_specifier_token = flags_specifier_token;
266 ast->lparen_token = lparen_token;
267 for (NameListAST *iter = flag_enums_list, **ast_iter = &ast->flag_enums_list;
268 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
269 *ast_iter = new (pool) NameListAST((iter->value) ? iter->value->clone(pool) : nullptr);
270 ast->rparen_token = rparen_token;
271 return ast;
272 }
273
clone(MemoryPool * pool) const274 QtInterfaceNameAST *QtInterfaceNameAST::clone(MemoryPool *pool) const
275 {
276 QtInterfaceNameAST *ast = new (pool) QtInterfaceNameAST;
277 if (interface_name)
278 ast->interface_name = interface_name->clone(pool);
279 for (NameListAST *iter = constraint_list, **ast_iter = &ast->constraint_list;
280 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
281 *ast_iter = new (pool) NameListAST((iter->value) ? iter->value->clone(pool) : nullptr);
282 return ast;
283 }
284
clone(MemoryPool * pool) const285 QtInterfacesDeclarationAST *QtInterfacesDeclarationAST::clone(MemoryPool *pool) const
286 {
287 QtInterfacesDeclarationAST *ast = new (pool) QtInterfacesDeclarationAST;
288 ast->interfaces_token = interfaces_token;
289 ast->lparen_token = lparen_token;
290 for (QtInterfaceNameListAST *iter = interface_name_list, **ast_iter = &ast->interface_name_list;
291 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
292 *ast_iter = new (pool) QtInterfaceNameListAST((iter->value) ? iter->value->clone(pool) : nullptr);
293 ast->rparen_token = rparen_token;
294 return ast;
295 }
296
clone(MemoryPool * pool) const297 AsmDefinitionAST *AsmDefinitionAST::clone(MemoryPool *pool) const
298 {
299 AsmDefinitionAST *ast = new (pool) AsmDefinitionAST;
300 ast->asm_token = asm_token;
301 ast->volatile_token = volatile_token;
302 ast->lparen_token = lparen_token;
303 ast->rparen_token = rparen_token;
304 ast->semicolon_token = semicolon_token;
305 return ast;
306 }
307
clone(MemoryPool * pool) const308 BaseSpecifierAST *BaseSpecifierAST::clone(MemoryPool *pool) const
309 {
310 BaseSpecifierAST *ast = new (pool) BaseSpecifierAST;
311 ast->virtual_token = virtual_token;
312 ast->access_specifier_token = access_specifier_token;
313 if (name)
314 ast->name = name->clone(pool);
315 ast->ellipsis_token = ellipsis_token;
316 return ast;
317 }
318
clone(MemoryPool * pool) const319 IdExpressionAST *IdExpressionAST::clone(MemoryPool *pool) const
320 {
321 IdExpressionAST *ast = new (pool) IdExpressionAST;
322 if (name)
323 ast->name = name->clone(pool);
324 return ast;
325 }
326
clone(MemoryPool * pool) const327 CompoundExpressionAST *CompoundExpressionAST::clone(MemoryPool *pool) const
328 {
329 CompoundExpressionAST *ast = new (pool) CompoundExpressionAST;
330 ast->lparen_token = lparen_token;
331 if (statement)
332 ast->statement = statement->clone(pool);
333 ast->rparen_token = rparen_token;
334 return ast;
335 }
336
clone(MemoryPool * pool) const337 CompoundLiteralAST *CompoundLiteralAST::clone(MemoryPool *pool) const
338 {
339 CompoundLiteralAST *ast = new (pool) CompoundLiteralAST;
340 ast->lparen_token = lparen_token;
341 if (type_id)
342 ast->type_id = type_id->clone(pool);
343 ast->rparen_token = rparen_token;
344 if (initializer)
345 ast->initializer = initializer->clone(pool);
346 return ast;
347 }
348
clone(MemoryPool * pool) const349 QtMethodAST *QtMethodAST::clone(MemoryPool *pool) const
350 {
351 QtMethodAST *ast = new (pool) QtMethodAST;
352 ast->method_token = method_token;
353 ast->lparen_token = lparen_token;
354 if (declarator)
355 ast->declarator = declarator->clone(pool);
356 ast->rparen_token = rparen_token;
357 return ast;
358 }
359
clone(MemoryPool * pool) const360 QtMemberDeclarationAST *QtMemberDeclarationAST::clone(MemoryPool *pool) const
361 {
362 QtMemberDeclarationAST *ast = new (pool) QtMemberDeclarationAST;
363 ast->q_token = q_token;
364 ast->lparen_token = lparen_token;
365 if (type_id)
366 ast->type_id = type_id->clone(pool);
367 ast->rparen_token = rparen_token;
368 return ast;
369 }
370
clone(MemoryPool * pool) const371 BinaryExpressionAST *BinaryExpressionAST::clone(MemoryPool *pool) const
372 {
373 BinaryExpressionAST *ast = new (pool) BinaryExpressionAST;
374 if (left_expression)
375 ast->left_expression = left_expression->clone(pool);
376 ast->binary_op_token = binary_op_token;
377 if (right_expression)
378 ast->right_expression = right_expression->clone(pool);
379 return ast;
380 }
381
clone(MemoryPool * pool) const382 CastExpressionAST *CastExpressionAST::clone(MemoryPool *pool) const
383 {
384 CastExpressionAST *ast = new (pool) CastExpressionAST;
385 ast->lparen_token = lparen_token;
386 if (type_id)
387 ast->type_id = type_id->clone(pool);
388 ast->rparen_token = rparen_token;
389 if (expression)
390 ast->expression = expression->clone(pool);
391 return ast;
392 }
393
clone(MemoryPool * pool) const394 ClassSpecifierAST *ClassSpecifierAST::clone(MemoryPool *pool) const
395 {
396 ClassSpecifierAST *ast = new (pool) ClassSpecifierAST;
397 ast->classkey_token = classkey_token;
398 for (SpecifierListAST *iter = attribute_list, **ast_iter = &ast->attribute_list;
399 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
400 *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : nullptr);
401 if (name)
402 ast->name = name->clone(pool);
403 ast->final_token = final_token;
404 ast->colon_token = colon_token;
405 for (BaseSpecifierListAST *iter = base_clause_list, **ast_iter = &ast->base_clause_list;
406 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
407 *ast_iter = new (pool) BaseSpecifierListAST((iter->value) ? iter->value->clone(pool) : nullptr);
408 ast->dot_dot_dot_token = dot_dot_dot_token;
409 ast->lbrace_token = lbrace_token;
410 for (DeclarationListAST *iter = member_specifier_list, **ast_iter = &ast->member_specifier_list;
411 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
412 *ast_iter = new (pool) DeclarationListAST((iter->value) ? iter->value->clone(pool) : nullptr);
413 ast->rbrace_token = rbrace_token;
414 return ast;
415 }
416
clone(MemoryPool * pool) const417 CaseStatementAST *CaseStatementAST::clone(MemoryPool *pool) const
418 {
419 CaseStatementAST *ast = new (pool) CaseStatementAST;
420 ast->case_token = case_token;
421 if (expression)
422 ast->expression = expression->clone(pool);
423 ast->colon_token = colon_token;
424 if (statement)
425 ast->statement = statement->clone(pool);
426 return ast;
427 }
428
clone(MemoryPool * pool) const429 CompoundStatementAST *CompoundStatementAST::clone(MemoryPool *pool) const
430 {
431 CompoundStatementAST *ast = new (pool) CompoundStatementAST;
432 ast->lbrace_token = lbrace_token;
433 for (StatementListAST *iter = statement_list, **ast_iter = &ast->statement_list;
434 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
435 *ast_iter = new (pool) StatementListAST((iter->value) ? iter->value->clone(pool) : nullptr);
436 ast->rbrace_token = rbrace_token;
437 return ast;
438 }
439
clone(MemoryPool * pool) const440 ConditionAST *ConditionAST::clone(MemoryPool *pool) const
441 {
442 ConditionAST *ast = new (pool) ConditionAST;
443 for (SpecifierListAST *iter = type_specifier_list, **ast_iter = &ast->type_specifier_list;
444 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
445 *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : nullptr);
446 if (declarator)
447 ast->declarator = declarator->clone(pool);
448 return ast;
449 }
450
clone(MemoryPool * pool) const451 ConditionalExpressionAST *ConditionalExpressionAST::clone(MemoryPool *pool) const
452 {
453 ConditionalExpressionAST *ast = new (pool) ConditionalExpressionAST;
454 if (condition)
455 ast->condition = condition->clone(pool);
456 ast->question_token = question_token;
457 if (left_expression)
458 ast->left_expression = left_expression->clone(pool);
459 ast->colon_token = colon_token;
460 if (right_expression)
461 ast->right_expression = right_expression->clone(pool);
462 return ast;
463 }
464
clone(MemoryPool * pool) const465 CppCastExpressionAST *CppCastExpressionAST::clone(MemoryPool *pool) const
466 {
467 CppCastExpressionAST *ast = new (pool) CppCastExpressionAST;
468 ast->cast_token = cast_token;
469 ast->less_token = less_token;
470 if (type_id)
471 ast->type_id = type_id->clone(pool);
472 ast->greater_token = greater_token;
473 ast->lparen_token = lparen_token;
474 if (expression)
475 ast->expression = expression->clone(pool);
476 ast->rparen_token = rparen_token;
477 return ast;
478 }
479
clone(MemoryPool * pool) const480 CtorInitializerAST *CtorInitializerAST::clone(MemoryPool *pool) const
481 {
482 CtorInitializerAST *ast = new (pool) CtorInitializerAST;
483 ast->colon_token = colon_token;
484 for (MemInitializerListAST *iter = member_initializer_list, **ast_iter = &ast->member_initializer_list;
485 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
486 *ast_iter = new (pool) MemInitializerListAST((iter->value) ? iter->value->clone(pool) : nullptr);
487 ast->dot_dot_dot_token = dot_dot_dot_token;
488 return ast;
489 }
490
clone(MemoryPool * pool) const491 DeclarationStatementAST *DeclarationStatementAST::clone(MemoryPool *pool) const
492 {
493 DeclarationStatementAST *ast = new (pool) DeclarationStatementAST;
494 if (declaration)
495 ast->declaration = declaration->clone(pool);
496 return ast;
497 }
498
clone(MemoryPool * pool) const499 DeclaratorIdAST *DeclaratorIdAST::clone(MemoryPool *pool) const
500 {
501 DeclaratorIdAST *ast = new (pool) DeclaratorIdAST;
502 ast->dot_dot_dot_token = dot_dot_dot_token;
503 if (name)
504 ast->name = name->clone(pool);
505 return ast;
506 }
507
clone(MemoryPool * pool) const508 NestedDeclaratorAST *NestedDeclaratorAST::clone(MemoryPool *pool) const
509 {
510 NestedDeclaratorAST *ast = new (pool) NestedDeclaratorAST;
511 ast->lparen_token = lparen_token;
512 if (declarator)
513 ast->declarator = declarator->clone(pool);
514 ast->rparen_token = rparen_token;
515 return ast;
516 }
517
clone(MemoryPool * pool) const518 FunctionDeclaratorAST *FunctionDeclaratorAST::clone(MemoryPool *pool) const
519 {
520 FunctionDeclaratorAST *ast = new (pool) FunctionDeclaratorAST;
521 ast->lparen_token = lparen_token;
522 if (parameter_declaration_clause)
523 ast->parameter_declaration_clause = parameter_declaration_clause->clone(pool);
524 ast->rparen_token = rparen_token;
525 for (SpecifierListAST *iter = cv_qualifier_list, **ast_iter = &ast->cv_qualifier_list;
526 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
527 *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : nullptr);
528 ast->ref_qualifier_token = ref_qualifier_token;
529 if (exception_specification)
530 ast->exception_specification = exception_specification->clone(pool);
531 if (trailing_return_type)
532 ast->trailing_return_type = trailing_return_type->clone(pool);
533 if (as_cpp_initializer)
534 ast->as_cpp_initializer = as_cpp_initializer->clone(pool);
535 return ast;
536 }
537
clone(MemoryPool * pool) const538 ArrayDeclaratorAST *ArrayDeclaratorAST::clone(MemoryPool *pool) const
539 {
540 ArrayDeclaratorAST *ast = new (pool) ArrayDeclaratorAST;
541 ast->lbracket_token = lbracket_token;
542 if (expression)
543 ast->expression = expression->clone(pool);
544 ast->rbracket_token = rbracket_token;
545 return ast;
546 }
547
clone(MemoryPool * pool) const548 DeleteExpressionAST *DeleteExpressionAST::clone(MemoryPool *pool) const
549 {
550 DeleteExpressionAST *ast = new (pool) DeleteExpressionAST;
551 ast->scope_token = scope_token;
552 ast->delete_token = delete_token;
553 ast->lbracket_token = lbracket_token;
554 ast->rbracket_token = rbracket_token;
555 if (expression)
556 ast->expression = expression->clone(pool);
557 return ast;
558 }
559
clone(MemoryPool * pool) const560 DoStatementAST *DoStatementAST::clone(MemoryPool *pool) const
561 {
562 DoStatementAST *ast = new (pool) DoStatementAST;
563 ast->do_token = do_token;
564 if (statement)
565 ast->statement = statement->clone(pool);
566 ast->while_token = while_token;
567 ast->lparen_token = lparen_token;
568 if (expression)
569 ast->expression = expression->clone(pool);
570 ast->rparen_token = rparen_token;
571 ast->semicolon_token = semicolon_token;
572 return ast;
573 }
574
clone(MemoryPool * pool) const575 NamedTypeSpecifierAST *NamedTypeSpecifierAST::clone(MemoryPool *pool) const
576 {
577 NamedTypeSpecifierAST *ast = new (pool) NamedTypeSpecifierAST;
578 if (name)
579 ast->name = name->clone(pool);
580 return ast;
581 }
582
clone(MemoryPool * pool) const583 ElaboratedTypeSpecifierAST *ElaboratedTypeSpecifierAST::clone(MemoryPool *pool) const
584 {
585 ElaboratedTypeSpecifierAST *ast = new (pool) ElaboratedTypeSpecifierAST;
586 ast->classkey_token = classkey_token;
587 for (SpecifierListAST *iter = attribute_list, **ast_iter = &ast->attribute_list;
588 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
589 *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : nullptr);
590 if (name)
591 ast->name = name->clone(pool);
592 return ast;
593 }
594
clone(MemoryPool * pool) const595 EnumSpecifierAST *EnumSpecifierAST::clone(MemoryPool *pool) const
596 {
597 EnumSpecifierAST *ast = new (pool) EnumSpecifierAST;
598 ast->enum_token = enum_token;
599 ast->key_token = key_token;
600 if (name)
601 ast->name = name->clone(pool);
602 ast->colon_token = colon_token;
603 for (SpecifierListAST *iter = type_specifier_list, **ast_iter = &ast->type_specifier_list;
604 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
605 *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : nullptr);
606 ast->lbrace_token = lbrace_token;
607 for (EnumeratorListAST *iter = enumerator_list, **ast_iter = &ast->enumerator_list;
608 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
609 *ast_iter = new (pool) EnumeratorListAST((iter->value) ? iter->value->clone(pool) : nullptr);
610 ast->stray_comma_token = stray_comma_token;
611 ast->rbrace_token = rbrace_token;
612 return ast;
613 }
614
clone(MemoryPool * pool) const615 EnumeratorAST *EnumeratorAST::clone(MemoryPool *pool) const
616 {
617 EnumeratorAST *ast = new (pool) EnumeratorAST;
618 ast->identifier_token = identifier_token;
619 ast->equal_token = equal_token;
620 if (expression)
621 ast->expression = expression->clone(pool);
622 return ast;
623 }
624
clone(MemoryPool * pool) const625 ExceptionDeclarationAST *ExceptionDeclarationAST::clone(MemoryPool *pool) const
626 {
627 ExceptionDeclarationAST *ast = new (pool) ExceptionDeclarationAST;
628 for (SpecifierListAST *iter = type_specifier_list, **ast_iter = &ast->type_specifier_list;
629 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
630 *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : nullptr);
631 if (declarator)
632 ast->declarator = declarator->clone(pool);
633 ast->dot_dot_dot_token = dot_dot_dot_token;
634 return ast;
635 }
636
clone(MemoryPool * pool) const637 DynamicExceptionSpecificationAST *DynamicExceptionSpecificationAST::clone(MemoryPool *pool) const
638 {
639 DynamicExceptionSpecificationAST *ast = new (pool) DynamicExceptionSpecificationAST;
640 ast->throw_token = throw_token;
641 ast->lparen_token = lparen_token;
642 ast->dot_dot_dot_token = dot_dot_dot_token;
643 for (ExpressionListAST *iter = type_id_list, **ast_iter = &ast->type_id_list;
644 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
645 *ast_iter = new (pool) ExpressionListAST((iter->value) ? iter->value->clone(pool) : nullptr);
646 ast->rparen_token = rparen_token;
647 return ast;
648 }
649
clone(MemoryPool * pool) const650 NoExceptSpecificationAST *NoExceptSpecificationAST::clone(MemoryPool *pool) const
651 {
652 NoExceptSpecificationAST *ast = new (pool) NoExceptSpecificationAST;
653 ast->noexcept_token = noexcept_token;
654 ast->lparen_token = lparen_token;
655 if (expression)
656 ast->expression = expression->clone(pool);
657 ast->rparen_token = rparen_token;
658 return ast;
659 }
660
clone(MemoryPool * pool) const661 ExpressionOrDeclarationStatementAST *ExpressionOrDeclarationStatementAST::clone(MemoryPool *pool) const
662 {
663 ExpressionOrDeclarationStatementAST *ast = new (pool) ExpressionOrDeclarationStatementAST;
664 if (expression)
665 ast->expression = expression->clone(pool);
666 if (declaration)
667 ast->declaration = declaration->clone(pool);
668 return ast;
669 }
670
clone(MemoryPool * pool) const671 ExpressionStatementAST *ExpressionStatementAST::clone(MemoryPool *pool) const
672 {
673 ExpressionStatementAST *ast = new (pool) ExpressionStatementAST;
674 if (expression)
675 ast->expression = expression->clone(pool);
676 ast->semicolon_token = semicolon_token;
677 return ast;
678 }
679
clone(MemoryPool * pool) const680 FunctionDefinitionAST *FunctionDefinitionAST::clone(MemoryPool *pool) const
681 {
682 FunctionDefinitionAST *ast = new (pool) FunctionDefinitionAST;
683 ast->qt_invokable_token = qt_invokable_token;
684 for (SpecifierListAST *iter = decl_specifier_list, **ast_iter = &ast->decl_specifier_list;
685 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
686 *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : nullptr);
687 if (declarator)
688 ast->declarator = declarator->clone(pool);
689 if (ctor_initializer)
690 ast->ctor_initializer = ctor_initializer->clone(pool);
691 if (function_body)
692 ast->function_body = function_body->clone(pool);
693 return ast;
694 }
695
clone(MemoryPool * pool) const696 ForeachStatementAST *ForeachStatementAST::clone(MemoryPool *pool) const
697 {
698 ForeachStatementAST *ast = new (pool) ForeachStatementAST;
699 ast->foreach_token = foreach_token;
700 ast->lparen_token = lparen_token;
701 for (SpecifierListAST *iter = type_specifier_list, **ast_iter = &ast->type_specifier_list;
702 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
703 *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : nullptr);
704 if (declarator)
705 ast->declarator = declarator->clone(pool);
706 if (initializer)
707 ast->initializer = initializer->clone(pool);
708 ast->comma_token = comma_token;
709 if (expression)
710 ast->expression = expression->clone(pool);
711 ast->rparen_token = rparen_token;
712 if (statement)
713 ast->statement = statement->clone(pool);
714 return ast;
715 }
716
clone(MemoryPool * pool) const717 RangeBasedForStatementAST *RangeBasedForStatementAST::clone(MemoryPool *pool) const
718 {
719 RangeBasedForStatementAST *ast = new (pool) RangeBasedForStatementAST;
720 ast->for_token = for_token;
721 ast->lparen_token = lparen_token;
722 for (SpecifierListAST *iter = type_specifier_list, **ast_iter = &ast->type_specifier_list;
723 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
724 *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : nullptr);
725 if (declarator)
726 ast->declarator = declarator->clone(pool);
727 ast->colon_token = colon_token;
728 if (expression)
729 ast->expression = expression->clone(pool);
730 ast->rparen_token = rparen_token;
731 if (statement)
732 ast->statement = statement->clone(pool);
733 return ast;
734 }
735
clone(MemoryPool * pool) const736 ForStatementAST *ForStatementAST::clone(MemoryPool *pool) const
737 {
738 ForStatementAST *ast = new (pool) ForStatementAST;
739 ast->for_token = for_token;
740 ast->lparen_token = lparen_token;
741 if (initializer)
742 ast->initializer = initializer->clone(pool);
743 if (condition)
744 ast->condition = condition->clone(pool);
745 ast->semicolon_token = semicolon_token;
746 if (expression)
747 ast->expression = expression->clone(pool);
748 ast->rparen_token = rparen_token;
749 if (statement)
750 ast->statement = statement->clone(pool);
751 return ast;
752 }
753
clone(MemoryPool * pool) const754 IfStatementAST *IfStatementAST::clone(MemoryPool *pool) const
755 {
756 IfStatementAST *ast = new (pool) IfStatementAST;
757 ast->if_token = if_token;
758 ast->constexpr_token = constexpr_token;
759 ast->lparen_token = lparen_token;
760 if (condition)
761 ast->condition = condition->clone(pool);
762 ast->rparen_token = rparen_token;
763 if (statement)
764 ast->statement = statement->clone(pool);
765 ast->else_token = else_token;
766 if (else_statement)
767 ast->else_statement = else_statement->clone(pool);
768 return ast;
769 }
770
clone(MemoryPool * pool) const771 ArrayInitializerAST *ArrayInitializerAST::clone(MemoryPool *pool) const
772 {
773 ArrayInitializerAST *ast = new (pool) ArrayInitializerAST;
774 ast->lbrace_token = lbrace_token;
775 for (ExpressionListAST *iter = expression_list, **ast_iter = &ast->expression_list;
776 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
777 *ast_iter = new (pool) ExpressionListAST((iter->value) ? iter->value->clone(pool) : nullptr);
778 ast->rbrace_token = rbrace_token;
779 return ast;
780 }
781
clone(MemoryPool * pool) const782 LabeledStatementAST *LabeledStatementAST::clone(MemoryPool *pool) const
783 {
784 LabeledStatementAST *ast = new (pool) LabeledStatementAST;
785 ast->label_token = label_token;
786 ast->colon_token = colon_token;
787 if (statement)
788 ast->statement = statement->clone(pool);
789 return ast;
790 }
791
clone(MemoryPool * pool) const792 LinkageBodyAST *LinkageBodyAST::clone(MemoryPool *pool) const
793 {
794 LinkageBodyAST *ast = new (pool) LinkageBodyAST;
795 ast->lbrace_token = lbrace_token;
796 for (DeclarationListAST *iter = declaration_list, **ast_iter = &ast->declaration_list;
797 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
798 *ast_iter = new (pool) DeclarationListAST((iter->value) ? iter->value->clone(pool) : nullptr);
799 ast->rbrace_token = rbrace_token;
800 return ast;
801 }
802
clone(MemoryPool * pool) const803 LinkageSpecificationAST *LinkageSpecificationAST::clone(MemoryPool *pool) const
804 {
805 LinkageSpecificationAST *ast = new (pool) LinkageSpecificationAST;
806 ast->extern_token = extern_token;
807 ast->extern_type_token = extern_type_token;
808 if (declaration)
809 ast->declaration = declaration->clone(pool);
810 return ast;
811 }
812
clone(MemoryPool * pool) const813 MemInitializerAST *MemInitializerAST::clone(MemoryPool *pool) const
814 {
815 MemInitializerAST *ast = new (pool) MemInitializerAST;
816 if (name)
817 ast->name = name->clone(pool);
818 if (expression)
819 ast->expression = expression->clone(pool);
820 return ast;
821 }
822
clone(MemoryPool * pool) const823 NestedNameSpecifierAST *NestedNameSpecifierAST::clone(MemoryPool *pool) const
824 {
825 NestedNameSpecifierAST *ast = new (pool) NestedNameSpecifierAST;
826 if (class_or_namespace_name)
827 ast->class_or_namespace_name = class_or_namespace_name->clone(pool);
828 ast->scope_token = scope_token;
829 return ast;
830 }
831
clone(MemoryPool * pool) const832 QualifiedNameAST *QualifiedNameAST::clone(MemoryPool *pool) const
833 {
834 QualifiedNameAST *ast = new (pool) QualifiedNameAST;
835 ast->global_scope_token = global_scope_token;
836 for (NestedNameSpecifierListAST *iter = nested_name_specifier_list, **ast_iter = &ast->nested_name_specifier_list;
837 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
838 *ast_iter = new (pool) NestedNameSpecifierListAST((iter->value) ? iter->value->clone(pool) : nullptr);
839 if (unqualified_name)
840 ast->unqualified_name = unqualified_name->clone(pool);
841 return ast;
842 }
843
clone(MemoryPool * pool) const844 OperatorFunctionIdAST *OperatorFunctionIdAST::clone(MemoryPool *pool) const
845 {
846 OperatorFunctionIdAST *ast = new (pool) OperatorFunctionIdAST;
847 ast->operator_token = operator_token;
848 if (op)
849 ast->op = op->clone(pool);
850 return ast;
851 }
852
clone(MemoryPool * pool) const853 ConversionFunctionIdAST *ConversionFunctionIdAST::clone(MemoryPool *pool) const
854 {
855 ConversionFunctionIdAST *ast = new (pool) ConversionFunctionIdAST;
856 ast->operator_token = operator_token;
857 for (SpecifierListAST *iter = type_specifier_list, **ast_iter = &ast->type_specifier_list;
858 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
859 *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : nullptr);
860 for (PtrOperatorListAST *iter = ptr_operator_list, **ast_iter = &ast->ptr_operator_list;
861 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
862 *ast_iter = new (pool) PtrOperatorListAST((iter->value) ? iter->value->clone(pool) : nullptr);
863 return ast;
864 }
865
clone(MemoryPool * pool) const866 AnonymousNameAST *AnonymousNameAST::clone(MemoryPool *pool) const
867 {
868 AnonymousNameAST *ast = new (pool) AnonymousNameAST;
869 ast->class_token = class_token;
870 return ast;
871 }
872
clone(MemoryPool * pool) const873 SimpleNameAST *SimpleNameAST::clone(MemoryPool *pool) const
874 {
875 SimpleNameAST *ast = new (pool) SimpleNameAST;
876 ast->identifier_token = identifier_token;
877 return ast;
878 }
879
clone(MemoryPool * pool) const880 DestructorNameAST *DestructorNameAST::clone(MemoryPool *pool) const
881 {
882 DestructorNameAST *ast = new (pool) DestructorNameAST;
883 ast->tilde_token = tilde_token;
884 if (unqualified_name)
885 ast->unqualified_name = unqualified_name->clone(pool);
886 return ast;
887 }
888
clone(MemoryPool * pool) const889 TemplateIdAST *TemplateIdAST::clone(MemoryPool *pool) const
890 {
891 TemplateIdAST *ast = new (pool) TemplateIdAST;
892 ast->template_token = template_token;
893 ast->identifier_token = identifier_token;
894 ast->less_token = less_token;
895 for (ExpressionListAST *iter = template_argument_list, **ast_iter = &ast->template_argument_list;
896 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
897 *ast_iter = new (pool) ExpressionListAST((iter->value) ? iter->value->clone(pool) : nullptr);
898 ast->greater_token = greater_token;
899 return ast;
900 }
901
clone(MemoryPool * pool) const902 NamespaceAST *NamespaceAST::clone(MemoryPool *pool) const
903 {
904 NamespaceAST *ast = new (pool) NamespaceAST;
905 ast->inline_token = inline_token;
906 ast->namespace_token = namespace_token;
907 ast->identifier_token = identifier_token;
908 for (SpecifierListAST *iter = attribute_list, **ast_iter = &ast->attribute_list;
909 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
910 *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : nullptr);
911 if (linkage_body)
912 ast->linkage_body = linkage_body->clone(pool);
913 return ast;
914 }
915
clone(MemoryPool * pool) const916 NamespaceAliasDefinitionAST *NamespaceAliasDefinitionAST::clone(MemoryPool *pool) const
917 {
918 NamespaceAliasDefinitionAST *ast = new (pool) NamespaceAliasDefinitionAST;
919 ast->namespace_token = namespace_token;
920 ast->namespace_name_token = namespace_name_token;
921 ast->equal_token = equal_token;
922 if (name)
923 ast->name = name->clone(pool);
924 ast->semicolon_token = semicolon_token;
925 return ast;
926 }
927
clone(MemoryPool * pool) const928 AliasDeclarationAST *AliasDeclarationAST::clone(MemoryPool *pool) const
929 {
930 AliasDeclarationAST *ast = new (pool) AliasDeclarationAST;
931 ast->using_token = using_token;
932 if (name)
933 ast->name = name->clone(pool);
934 ast->equal_token = equal_token;
935 if (typeId)
936 ast->typeId = typeId->clone(pool);
937 ast->semicolon_token = semicolon_token;
938 return ast;
939 }
940
clone(MemoryPool * pool) const941 ExpressionListParenAST *ExpressionListParenAST::clone(MemoryPool *pool) const
942 {
943 ExpressionListParenAST *ast = new (pool) ExpressionListParenAST;
944 ast->lparen_token = lparen_token;
945 for (ExpressionListAST *iter = expression_list, **ast_iter = &ast->expression_list;
946 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
947 *ast_iter = new (pool) ExpressionListAST((iter->value) ? iter->value->clone(pool) : nullptr);
948 ast->rparen_token = rparen_token;
949 return ast;
950 }
951
clone(MemoryPool * pool) const952 NewArrayDeclaratorAST *NewArrayDeclaratorAST::clone(MemoryPool *pool) const
953 {
954 NewArrayDeclaratorAST *ast = new (pool) NewArrayDeclaratorAST;
955 ast->lbracket_token = lbracket_token;
956 if (expression)
957 ast->expression = expression->clone(pool);
958 ast->rbracket_token = rbracket_token;
959 return ast;
960 }
961
clone(MemoryPool * pool) const962 NewExpressionAST *NewExpressionAST::clone(MemoryPool *pool) const
963 {
964 NewExpressionAST *ast = new (pool) NewExpressionAST;
965 ast->scope_token = scope_token;
966 ast->new_token = new_token;
967 if (new_placement)
968 ast->new_placement = new_placement->clone(pool);
969 ast->lparen_token = lparen_token;
970 if (type_id)
971 ast->type_id = type_id->clone(pool);
972 ast->rparen_token = rparen_token;
973 if (new_type_id)
974 ast->new_type_id = new_type_id->clone(pool);
975 if (new_initializer)
976 ast->new_initializer = new_initializer->clone(pool);
977 return ast;
978 }
979
clone(MemoryPool * pool) const980 NewTypeIdAST *NewTypeIdAST::clone(MemoryPool *pool) const
981 {
982 NewTypeIdAST *ast = new (pool) NewTypeIdAST;
983 for (SpecifierListAST *iter = type_specifier_list, **ast_iter = &ast->type_specifier_list;
984 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
985 *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : nullptr);
986 for (PtrOperatorListAST *iter = ptr_operator_list, **ast_iter = &ast->ptr_operator_list;
987 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
988 *ast_iter = new (pool) PtrOperatorListAST((iter->value) ? iter->value->clone(pool) : nullptr);
989 for (NewArrayDeclaratorListAST *iter = new_array_declarator_list, **ast_iter = &ast->new_array_declarator_list;
990 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
991 *ast_iter = new (pool) NewArrayDeclaratorListAST((iter->value) ? iter->value->clone(pool) : nullptr);
992 return ast;
993 }
994
clone(MemoryPool * pool) const995 OperatorAST *OperatorAST::clone(MemoryPool *pool) const
996 {
997 OperatorAST *ast = new (pool) OperatorAST;
998 ast->op_token = op_token;
999 ast->open_token = open_token;
1000 ast->close_token = close_token;
1001 return ast;
1002 }
1003
clone(MemoryPool * pool) const1004 ParameterDeclarationAST *ParameterDeclarationAST::clone(MemoryPool *pool) const
1005 {
1006 ParameterDeclarationAST *ast = new (pool) ParameterDeclarationAST;
1007 for (SpecifierListAST *iter = type_specifier_list, **ast_iter = &ast->type_specifier_list;
1008 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1009 *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : nullptr);
1010 if (declarator)
1011 ast->declarator = declarator->clone(pool);
1012 ast->equal_token = equal_token;
1013 if (expression)
1014 ast->expression = expression->clone(pool);
1015 return ast;
1016 }
1017
clone(MemoryPool * pool) const1018 ParameterDeclarationClauseAST *ParameterDeclarationClauseAST::clone(MemoryPool *pool) const
1019 {
1020 ParameterDeclarationClauseAST *ast = new (pool) ParameterDeclarationClauseAST;
1021 for (ParameterDeclarationListAST *iter = parameter_declaration_list, **ast_iter = &ast->parameter_declaration_list;
1022 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1023 *ast_iter = new (pool) ParameterDeclarationListAST((iter->value) ? iter->value->clone(pool) : nullptr);
1024 ast->dot_dot_dot_token = dot_dot_dot_token;
1025 return ast;
1026 }
1027
clone(MemoryPool * pool) const1028 CallAST *CallAST::clone(MemoryPool *pool) const
1029 {
1030 CallAST *ast = new (pool) CallAST;
1031 if (base_expression)
1032 ast->base_expression = base_expression->clone(pool);
1033 ast->lparen_token = lparen_token;
1034 for (ExpressionListAST *iter = expression_list, **ast_iter = &ast->expression_list;
1035 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1036 *ast_iter = new (pool) ExpressionListAST((iter->value) ? iter->value->clone(pool) : nullptr);
1037 ast->rparen_token = rparen_token;
1038 return ast;
1039 }
1040
clone(MemoryPool * pool) const1041 ArrayAccessAST *ArrayAccessAST::clone(MemoryPool *pool) const
1042 {
1043 ArrayAccessAST *ast = new (pool) ArrayAccessAST;
1044 if (base_expression)
1045 ast->base_expression = base_expression->clone(pool);
1046 ast->lbracket_token = lbracket_token;
1047 if (expression)
1048 ast->expression = expression->clone(pool);
1049 ast->rbracket_token = rbracket_token;
1050 return ast;
1051 }
1052
clone(MemoryPool * pool) const1053 PostIncrDecrAST *PostIncrDecrAST::clone(MemoryPool *pool) const
1054 {
1055 PostIncrDecrAST *ast = new (pool) PostIncrDecrAST;
1056 if (base_expression)
1057 ast->base_expression = base_expression->clone(pool);
1058 ast->incr_decr_token = incr_decr_token;
1059 return ast;
1060 }
1061
clone(MemoryPool * pool) const1062 MemberAccessAST *MemberAccessAST::clone(MemoryPool *pool) const
1063 {
1064 MemberAccessAST *ast = new (pool) MemberAccessAST;
1065 if (base_expression)
1066 ast->base_expression = base_expression->clone(pool);
1067 ast->access_token = access_token;
1068 ast->template_token = template_token;
1069 if (member_name)
1070 ast->member_name = member_name->clone(pool);
1071 return ast;
1072 }
1073
clone(MemoryPool * pool) const1074 TypeidExpressionAST *TypeidExpressionAST::clone(MemoryPool *pool) const
1075 {
1076 TypeidExpressionAST *ast = new (pool) TypeidExpressionAST;
1077 ast->typeid_token = typeid_token;
1078 ast->lparen_token = lparen_token;
1079 if (expression)
1080 ast->expression = expression->clone(pool);
1081 ast->rparen_token = rparen_token;
1082 return ast;
1083 }
1084
clone(MemoryPool * pool) const1085 TypenameCallExpressionAST *TypenameCallExpressionAST::clone(MemoryPool *pool) const
1086 {
1087 TypenameCallExpressionAST *ast = new (pool) TypenameCallExpressionAST;
1088 ast->typename_token = typename_token;
1089 if (name)
1090 ast->name = name->clone(pool);
1091 if (expression)
1092 ast->expression = expression->clone(pool);
1093 return ast;
1094 }
1095
clone(MemoryPool * pool) const1096 TypeConstructorCallAST *TypeConstructorCallAST::clone(MemoryPool *pool) const
1097 {
1098 TypeConstructorCallAST *ast = new (pool) TypeConstructorCallAST;
1099 for (SpecifierListAST *iter = type_specifier_list, **ast_iter = &ast->type_specifier_list;
1100 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1101 *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : nullptr);
1102 if (expression)
1103 ast->expression = expression->clone(pool);
1104 return ast;
1105 }
1106
clone(MemoryPool * pool) const1107 PointerToMemberAST *PointerToMemberAST::clone(MemoryPool *pool) const
1108 {
1109 PointerToMemberAST *ast = new (pool) PointerToMemberAST;
1110 ast->global_scope_token = global_scope_token;
1111 for (NestedNameSpecifierListAST *iter = nested_name_specifier_list, **ast_iter = &ast->nested_name_specifier_list;
1112 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1113 *ast_iter = new (pool) NestedNameSpecifierListAST((iter->value) ? iter->value->clone(pool) : nullptr);
1114 ast->star_token = star_token;
1115 for (SpecifierListAST *iter = cv_qualifier_list, **ast_iter = &ast->cv_qualifier_list;
1116 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1117 *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : nullptr);
1118 ast->ref_qualifier_token = ref_qualifier_token;
1119 return ast;
1120 }
1121
clone(MemoryPool * pool) const1122 PointerAST *PointerAST::clone(MemoryPool *pool) const
1123 {
1124 PointerAST *ast = new (pool) PointerAST;
1125 ast->star_token = star_token;
1126 for (SpecifierListAST *iter = cv_qualifier_list, **ast_iter = &ast->cv_qualifier_list;
1127 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1128 *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : nullptr);
1129 return ast;
1130 }
1131
clone(MemoryPool * pool) const1132 ReferenceAST *ReferenceAST::clone(MemoryPool *pool) const
1133 {
1134 ReferenceAST *ast = new (pool) ReferenceAST;
1135 ast->reference_token = reference_token;
1136 return ast;
1137 }
1138
clone(MemoryPool * pool) const1139 BreakStatementAST *BreakStatementAST::clone(MemoryPool *pool) const
1140 {
1141 BreakStatementAST *ast = new (pool) BreakStatementAST;
1142 ast->break_token = break_token;
1143 ast->semicolon_token = semicolon_token;
1144 return ast;
1145 }
1146
clone(MemoryPool * pool) const1147 ContinueStatementAST *ContinueStatementAST::clone(MemoryPool *pool) const
1148 {
1149 ContinueStatementAST *ast = new (pool) ContinueStatementAST;
1150 ast->continue_token = continue_token;
1151 ast->semicolon_token = semicolon_token;
1152 return ast;
1153 }
1154
clone(MemoryPool * pool) const1155 GotoStatementAST *GotoStatementAST::clone(MemoryPool *pool) const
1156 {
1157 GotoStatementAST *ast = new (pool) GotoStatementAST;
1158 ast->goto_token = goto_token;
1159 ast->identifier_token = identifier_token;
1160 ast->semicolon_token = semicolon_token;
1161 return ast;
1162 }
1163
clone(MemoryPool * pool) const1164 ReturnStatementAST *ReturnStatementAST::clone(MemoryPool *pool) const
1165 {
1166 ReturnStatementAST *ast = new (pool) ReturnStatementAST;
1167 ast->return_token = return_token;
1168 if (expression)
1169 ast->expression = expression->clone(pool);
1170 ast->semicolon_token = semicolon_token;
1171 return ast;
1172 }
1173
clone(MemoryPool * pool) const1174 SizeofExpressionAST *SizeofExpressionAST::clone(MemoryPool *pool) const
1175 {
1176 SizeofExpressionAST *ast = new (pool) SizeofExpressionAST;
1177 ast->sizeof_token = sizeof_token;
1178 ast->dot_dot_dot_token = dot_dot_dot_token;
1179 ast->lparen_token = lparen_token;
1180 if (expression)
1181 ast->expression = expression->clone(pool);
1182 ast->rparen_token = rparen_token;
1183 return ast;
1184 }
1185
clone(MemoryPool * pool) const1186 AlignofExpressionAST *AlignofExpressionAST::clone(MemoryPool *pool) const
1187 {
1188 AlignofExpressionAST *ast = new (pool) AlignofExpressionAST;
1189 ast->alignof_token = alignof_token;
1190 ast->lparen_token = lparen_token;
1191 if (typeId)
1192 ast->typeId = typeId->clone(pool);
1193 ast->rparen_token = rparen_token;
1194 return ast;
1195 }
1196
clone(MemoryPool * pool) const1197 PointerLiteralAST *PointerLiteralAST::clone(MemoryPool *pool) const
1198 {
1199 PointerLiteralAST *ast = new (pool) PointerLiteralAST;
1200 ast->literal_token = literal_token;
1201 return ast;
1202 }
1203
clone(MemoryPool * pool) const1204 NumericLiteralAST *NumericLiteralAST::clone(MemoryPool *pool) const
1205 {
1206 NumericLiteralAST *ast = new (pool) NumericLiteralAST;
1207 ast->literal_token = literal_token;
1208 return ast;
1209 }
1210
clone(MemoryPool * pool) const1211 BoolLiteralAST *BoolLiteralAST::clone(MemoryPool *pool) const
1212 {
1213 BoolLiteralAST *ast = new (pool) BoolLiteralAST;
1214 ast->literal_token = literal_token;
1215 return ast;
1216 }
1217
clone(MemoryPool * pool) const1218 ThisExpressionAST *ThisExpressionAST::clone(MemoryPool *pool) const
1219 {
1220 ThisExpressionAST *ast = new (pool) ThisExpressionAST;
1221 ast->this_token = this_token;
1222 return ast;
1223 }
1224
clone(MemoryPool * pool) const1225 NestedExpressionAST *NestedExpressionAST::clone(MemoryPool *pool) const
1226 {
1227 NestedExpressionAST *ast = new (pool) NestedExpressionAST;
1228 ast->lparen_token = lparen_token;
1229 if (expression)
1230 ast->expression = expression->clone(pool);
1231 ast->rparen_token = rparen_token;
1232 return ast;
1233 }
1234
clone(MemoryPool * pool) const1235 StaticAssertDeclarationAST *StaticAssertDeclarationAST::clone(MemoryPool *pool) const
1236 {
1237 StaticAssertDeclarationAST *ast = new (pool) StaticAssertDeclarationAST;
1238 ast->static_assert_token = static_assert_token;
1239 ast->lparen_token = lparen_token;
1240 if (expression)
1241 ast->expression = expression->clone(pool);
1242 ast->comma_token = comma_token;
1243 if (string_literal)
1244 ast->string_literal = string_literal->clone(pool);
1245 ast->rparen_token = rparen_token;
1246 ast->semicolon_token = semicolon_token;
1247 return ast;
1248 }
1249
clone(MemoryPool * pool) const1250 StringLiteralAST *StringLiteralAST::clone(MemoryPool *pool) const
1251 {
1252 StringLiteralAST *ast = new (pool) StringLiteralAST;
1253 ast->literal_token = literal_token;
1254 if (next)
1255 ast->next = next->clone(pool);
1256 return ast;
1257 }
1258
clone(MemoryPool * pool) const1259 SwitchStatementAST *SwitchStatementAST::clone(MemoryPool *pool) const
1260 {
1261 SwitchStatementAST *ast = new (pool) SwitchStatementAST;
1262 ast->switch_token = switch_token;
1263 ast->lparen_token = lparen_token;
1264 if (condition)
1265 ast->condition = condition->clone(pool);
1266 ast->rparen_token = rparen_token;
1267 if (statement)
1268 ast->statement = statement->clone(pool);
1269 return ast;
1270 }
1271
clone(MemoryPool * pool) const1272 TemplateDeclarationAST *TemplateDeclarationAST::clone(MemoryPool *pool) const
1273 {
1274 TemplateDeclarationAST *ast = new (pool) TemplateDeclarationAST;
1275 ast->export_token = export_token;
1276 ast->template_token = template_token;
1277 ast->less_token = less_token;
1278 for (DeclarationListAST *iter = template_parameter_list, **ast_iter = &ast->template_parameter_list;
1279 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1280 *ast_iter = new (pool) DeclarationListAST((iter->value) ? iter->value->clone(pool) : nullptr);
1281 ast->greater_token = greater_token;
1282 if (declaration)
1283 ast->declaration = declaration->clone(pool);
1284 return ast;
1285 }
1286
clone(MemoryPool * pool) const1287 ThrowExpressionAST *ThrowExpressionAST::clone(MemoryPool *pool) const
1288 {
1289 ThrowExpressionAST *ast = new (pool) ThrowExpressionAST;
1290 ast->throw_token = throw_token;
1291 if (expression)
1292 ast->expression = expression->clone(pool);
1293 return ast;
1294 }
1295
clone(MemoryPool * pool) const1296 NoExceptOperatorExpressionAST *NoExceptOperatorExpressionAST::clone(MemoryPool *pool) const
1297 {
1298 NoExceptOperatorExpressionAST *ast = new (pool) NoExceptOperatorExpressionAST;
1299 ast->noexcept_token = noexcept_token;
1300 if (expression)
1301 ast->expression = expression->clone(pool);
1302 return ast;
1303 }
1304
clone(MemoryPool * pool) const1305 TranslationUnitAST *TranslationUnitAST::clone(MemoryPool *pool) const
1306 {
1307 TranslationUnitAST *ast = new (pool) TranslationUnitAST;
1308 for (DeclarationListAST *iter = declaration_list, **ast_iter = &ast->declaration_list;
1309 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1310 *ast_iter = new (pool) DeclarationListAST((iter->value) ? iter->value->clone(pool) : nullptr);
1311 return ast;
1312 }
1313
clone(MemoryPool * pool) const1314 TryBlockStatementAST *TryBlockStatementAST::clone(MemoryPool *pool) const
1315 {
1316 TryBlockStatementAST *ast = new (pool) TryBlockStatementAST;
1317 ast->try_token = try_token;
1318 if (statement)
1319 ast->statement = statement->clone(pool);
1320 for (CatchClauseListAST *iter = catch_clause_list, **ast_iter = &ast->catch_clause_list;
1321 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1322 *ast_iter = new (pool) CatchClauseListAST((iter->value) ? iter->value->clone(pool) : nullptr);
1323 return ast;
1324 }
1325
clone(MemoryPool * pool) const1326 CatchClauseAST *CatchClauseAST::clone(MemoryPool *pool) const
1327 {
1328 CatchClauseAST *ast = new (pool) CatchClauseAST;
1329 ast->catch_token = catch_token;
1330 ast->lparen_token = lparen_token;
1331 if (exception_declaration)
1332 ast->exception_declaration = exception_declaration->clone(pool);
1333 ast->rparen_token = rparen_token;
1334 if (statement)
1335 ast->statement = statement->clone(pool);
1336 return ast;
1337 }
1338
clone(MemoryPool * pool) const1339 TypeIdAST *TypeIdAST::clone(MemoryPool *pool) const
1340 {
1341 TypeIdAST *ast = new (pool) TypeIdAST;
1342 for (SpecifierListAST *iter = type_specifier_list, **ast_iter = &ast->type_specifier_list;
1343 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1344 *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : nullptr);
1345 if (declarator)
1346 ast->declarator = declarator->clone(pool);
1347 return ast;
1348 }
1349
clone(MemoryPool * pool) const1350 TypenameTypeParameterAST *TypenameTypeParameterAST::clone(MemoryPool *pool) const
1351 {
1352 TypenameTypeParameterAST *ast = new (pool) TypenameTypeParameterAST;
1353 ast->classkey_token = classkey_token;
1354 ast->dot_dot_dot_token = dot_dot_dot_token;
1355 if (name)
1356 ast->name = name->clone(pool);
1357 ast->equal_token = equal_token;
1358 if (type_id)
1359 ast->type_id = type_id->clone(pool);
1360 return ast;
1361 }
1362
clone(MemoryPool * pool) const1363 TemplateTypeParameterAST *TemplateTypeParameterAST::clone(MemoryPool *pool) const
1364 {
1365 TemplateTypeParameterAST *ast = new (pool) TemplateTypeParameterAST;
1366 ast->template_token = template_token;
1367 ast->less_token = less_token;
1368 for (DeclarationListAST *iter = template_parameter_list, **ast_iter = &ast->template_parameter_list;
1369 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1370 *ast_iter = new (pool) DeclarationListAST((iter->value) ? iter->value->clone(pool) : nullptr);
1371 ast->greater_token = greater_token;
1372 ast->class_token = class_token;
1373 ast->dot_dot_dot_token = dot_dot_dot_token;
1374 if (name)
1375 ast->name = name->clone(pool);
1376 ast->equal_token = equal_token;
1377 if (type_id)
1378 ast->type_id = type_id->clone(pool);
1379 return ast;
1380 }
1381
clone(MemoryPool * pool) const1382 UnaryExpressionAST *UnaryExpressionAST::clone(MemoryPool *pool) const
1383 {
1384 UnaryExpressionAST *ast = new (pool) UnaryExpressionAST;
1385 ast->unary_op_token = unary_op_token;
1386 if (expression)
1387 ast->expression = expression->clone(pool);
1388 return ast;
1389 }
1390
clone(MemoryPool * pool) const1391 UsingAST *UsingAST::clone(MemoryPool *pool) const
1392 {
1393 UsingAST *ast = new (pool) UsingAST;
1394 ast->using_token = using_token;
1395 ast->typename_token = typename_token;
1396 if (name)
1397 ast->name = name->clone(pool);
1398 ast->semicolon_token = semicolon_token;
1399 return ast;
1400 }
1401
clone(MemoryPool * pool) const1402 UsingDirectiveAST *UsingDirectiveAST::clone(MemoryPool *pool) const
1403 {
1404 UsingDirectiveAST *ast = new (pool) UsingDirectiveAST;
1405 ast->using_token = using_token;
1406 ast->namespace_token = namespace_token;
1407 if (name)
1408 ast->name = name->clone(pool);
1409 ast->semicolon_token = semicolon_token;
1410 return ast;
1411 }
1412
clone(MemoryPool * pool) const1413 WhileStatementAST *WhileStatementAST::clone(MemoryPool *pool) const
1414 {
1415 WhileStatementAST *ast = new (pool) WhileStatementAST;
1416 ast->while_token = while_token;
1417 ast->lparen_token = lparen_token;
1418 if (condition)
1419 ast->condition = condition->clone(pool);
1420 ast->rparen_token = rparen_token;
1421 if (statement)
1422 ast->statement = statement->clone(pool);
1423 return ast;
1424 }
1425
clone(MemoryPool * pool) const1426 ObjCClassForwardDeclarationAST *ObjCClassForwardDeclarationAST::clone(MemoryPool *pool) const
1427 {
1428 ObjCClassForwardDeclarationAST *ast = new (pool) ObjCClassForwardDeclarationAST;
1429 for (SpecifierListAST *iter = attribute_list, **ast_iter = &ast->attribute_list;
1430 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1431 *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : nullptr);
1432 ast->class_token = class_token;
1433 for (NameListAST *iter = identifier_list, **ast_iter = &ast->identifier_list;
1434 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1435 *ast_iter = new (pool) NameListAST((iter->value) ? iter->value->clone(pool) : nullptr);
1436 ast->semicolon_token = semicolon_token;
1437 return ast;
1438 }
1439
clone(MemoryPool * pool) const1440 ObjCClassDeclarationAST *ObjCClassDeclarationAST::clone(MemoryPool *pool) const
1441 {
1442 ObjCClassDeclarationAST *ast = new (pool) ObjCClassDeclarationAST;
1443 for (SpecifierListAST *iter = attribute_list, **ast_iter = &ast->attribute_list;
1444 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1445 *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : nullptr);
1446 ast->interface_token = interface_token;
1447 ast->implementation_token = implementation_token;
1448 if (class_name)
1449 ast->class_name = class_name->clone(pool);
1450 ast->lparen_token = lparen_token;
1451 if (category_name)
1452 ast->category_name = category_name->clone(pool);
1453 ast->rparen_token = rparen_token;
1454 ast->colon_token = colon_token;
1455 if (superclass)
1456 ast->superclass = superclass->clone(pool);
1457 if (protocol_refs)
1458 ast->protocol_refs = protocol_refs->clone(pool);
1459 if (inst_vars_decl)
1460 ast->inst_vars_decl = inst_vars_decl->clone(pool);
1461 for (DeclarationListAST *iter = member_declaration_list, **ast_iter = &ast->member_declaration_list;
1462 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1463 *ast_iter = new (pool) DeclarationListAST((iter->value) ? iter->value->clone(pool) : nullptr);
1464 ast->end_token = end_token;
1465 return ast;
1466 }
1467
clone(MemoryPool * pool) const1468 ObjCProtocolForwardDeclarationAST *ObjCProtocolForwardDeclarationAST::clone(MemoryPool *pool) const
1469 {
1470 ObjCProtocolForwardDeclarationAST *ast = new (pool) ObjCProtocolForwardDeclarationAST;
1471 for (SpecifierListAST *iter = attribute_list, **ast_iter = &ast->attribute_list;
1472 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1473 *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : nullptr);
1474 ast->protocol_token = protocol_token;
1475 for (NameListAST *iter = identifier_list, **ast_iter = &ast->identifier_list;
1476 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1477 *ast_iter = new (pool) NameListAST((iter->value) ? iter->value->clone(pool) : nullptr);
1478 ast->semicolon_token = semicolon_token;
1479 return ast;
1480 }
1481
clone(MemoryPool * pool) const1482 ObjCProtocolDeclarationAST *ObjCProtocolDeclarationAST::clone(MemoryPool *pool) const
1483 {
1484 ObjCProtocolDeclarationAST *ast = new (pool) ObjCProtocolDeclarationAST;
1485 for (SpecifierListAST *iter = attribute_list, **ast_iter = &ast->attribute_list;
1486 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1487 *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : nullptr);
1488 ast->protocol_token = protocol_token;
1489 if (name)
1490 ast->name = name->clone(pool);
1491 if (protocol_refs)
1492 ast->protocol_refs = protocol_refs->clone(pool);
1493 for (DeclarationListAST *iter = member_declaration_list, **ast_iter = &ast->member_declaration_list;
1494 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1495 *ast_iter = new (pool) DeclarationListAST((iter->value) ? iter->value->clone(pool) : nullptr);
1496 ast->end_token = end_token;
1497 return ast;
1498 }
1499
clone(MemoryPool * pool) const1500 ObjCProtocolRefsAST *ObjCProtocolRefsAST::clone(MemoryPool *pool) const
1501 {
1502 ObjCProtocolRefsAST *ast = new (pool) ObjCProtocolRefsAST;
1503 ast->less_token = less_token;
1504 for (NameListAST *iter = identifier_list, **ast_iter = &ast->identifier_list;
1505 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1506 *ast_iter = new (pool) NameListAST((iter->value) ? iter->value->clone(pool) : nullptr);
1507 ast->greater_token = greater_token;
1508 return ast;
1509 }
1510
clone(MemoryPool * pool) const1511 ObjCMessageArgumentAST *ObjCMessageArgumentAST::clone(MemoryPool *pool) const
1512 {
1513 ObjCMessageArgumentAST *ast = new (pool) ObjCMessageArgumentAST;
1514 if (parameter_value_expression)
1515 ast->parameter_value_expression = parameter_value_expression->clone(pool);
1516 return ast;
1517 }
1518
clone(MemoryPool * pool) const1519 ObjCMessageExpressionAST *ObjCMessageExpressionAST::clone(MemoryPool *pool) const
1520 {
1521 ObjCMessageExpressionAST *ast = new (pool) ObjCMessageExpressionAST;
1522 ast->lbracket_token = lbracket_token;
1523 if (receiver_expression)
1524 ast->receiver_expression = receiver_expression->clone(pool);
1525 if (selector)
1526 ast->selector = selector->clone(pool);
1527 for (ObjCMessageArgumentListAST *iter = argument_list, **ast_iter = &ast->argument_list;
1528 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1529 *ast_iter = new (pool) ObjCMessageArgumentListAST((iter->value) ? iter->value->clone(pool) : nullptr);
1530 ast->rbracket_token = rbracket_token;
1531 return ast;
1532 }
1533
clone(MemoryPool * pool) const1534 ObjCProtocolExpressionAST *ObjCProtocolExpressionAST::clone(MemoryPool *pool) const
1535 {
1536 ObjCProtocolExpressionAST *ast = new (pool) ObjCProtocolExpressionAST;
1537 ast->protocol_token = protocol_token;
1538 ast->lparen_token = lparen_token;
1539 ast->identifier_token = identifier_token;
1540 ast->rparen_token = rparen_token;
1541 return ast;
1542 }
1543
clone(MemoryPool * pool) const1544 ObjCTypeNameAST *ObjCTypeNameAST::clone(MemoryPool *pool) const
1545 {
1546 ObjCTypeNameAST *ast = new (pool) ObjCTypeNameAST;
1547 ast->lparen_token = lparen_token;
1548 ast->type_qualifier_token = type_qualifier_token;
1549 if (type_id)
1550 ast->type_id = type_id->clone(pool);
1551 ast->rparen_token = rparen_token;
1552 return ast;
1553 }
1554
clone(MemoryPool * pool) const1555 ObjCEncodeExpressionAST *ObjCEncodeExpressionAST::clone(MemoryPool *pool) const
1556 {
1557 ObjCEncodeExpressionAST *ast = new (pool) ObjCEncodeExpressionAST;
1558 ast->encode_token = encode_token;
1559 if (type_name)
1560 ast->type_name = type_name->clone(pool);
1561 return ast;
1562 }
1563
clone(MemoryPool * pool) const1564 ObjCSelectorExpressionAST *ObjCSelectorExpressionAST::clone(MemoryPool *pool) const
1565 {
1566 ObjCSelectorExpressionAST *ast = new (pool) ObjCSelectorExpressionAST;
1567 ast->selector_token = selector_token;
1568 ast->lparen_token = lparen_token;
1569 if (selector)
1570 ast->selector = selector->clone(pool);
1571 ast->rparen_token = rparen_token;
1572 return ast;
1573 }
1574
clone(MemoryPool * pool) const1575 ObjCInstanceVariablesDeclarationAST *ObjCInstanceVariablesDeclarationAST::clone(MemoryPool *pool) const
1576 {
1577 ObjCInstanceVariablesDeclarationAST *ast = new (pool) ObjCInstanceVariablesDeclarationAST;
1578 ast->lbrace_token = lbrace_token;
1579 for (DeclarationListAST *iter = instance_variable_list, **ast_iter = &ast->instance_variable_list;
1580 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1581 *ast_iter = new (pool) DeclarationListAST((iter->value) ? iter->value->clone(pool) : nullptr);
1582 ast->rbrace_token = rbrace_token;
1583 return ast;
1584 }
1585
clone(MemoryPool * pool) const1586 ObjCVisibilityDeclarationAST *ObjCVisibilityDeclarationAST::clone(MemoryPool *pool) const
1587 {
1588 ObjCVisibilityDeclarationAST *ast = new (pool) ObjCVisibilityDeclarationAST;
1589 ast->visibility_token = visibility_token;
1590 return ast;
1591 }
1592
clone(MemoryPool * pool) const1593 ObjCPropertyAttributeAST *ObjCPropertyAttributeAST::clone(MemoryPool *pool) const
1594 {
1595 ObjCPropertyAttributeAST *ast = new (pool) ObjCPropertyAttributeAST;
1596 ast->attribute_identifier_token = attribute_identifier_token;
1597 ast->equals_token = equals_token;
1598 if (method_selector)
1599 ast->method_selector = method_selector->clone(pool);
1600 return ast;
1601 }
1602
clone(MemoryPool * pool) const1603 ObjCPropertyDeclarationAST *ObjCPropertyDeclarationAST::clone(MemoryPool *pool) const
1604 {
1605 ObjCPropertyDeclarationAST *ast = new (pool) ObjCPropertyDeclarationAST;
1606 for (SpecifierListAST *iter = attribute_list, **ast_iter = &ast->attribute_list;
1607 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1608 *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : nullptr);
1609 ast->property_token = property_token;
1610 ast->lparen_token = lparen_token;
1611 for (ObjCPropertyAttributeListAST *iter = property_attribute_list, **ast_iter = &ast->property_attribute_list;
1612 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1613 *ast_iter = new (pool) ObjCPropertyAttributeListAST((iter->value) ? iter->value->clone(pool) : nullptr);
1614 ast->rparen_token = rparen_token;
1615 if (simple_declaration)
1616 ast->simple_declaration = simple_declaration->clone(pool);
1617 return ast;
1618 }
1619
clone(MemoryPool * pool) const1620 ObjCMessageArgumentDeclarationAST *ObjCMessageArgumentDeclarationAST::clone(MemoryPool *pool) const
1621 {
1622 ObjCMessageArgumentDeclarationAST *ast = new (pool) ObjCMessageArgumentDeclarationAST;
1623 if (type_name)
1624 ast->type_name = type_name->clone(pool);
1625 for (SpecifierListAST *iter = attribute_list, **ast_iter = &ast->attribute_list;
1626 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1627 *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : nullptr);
1628 if (param_name)
1629 ast->param_name = param_name->clone(pool);
1630 return ast;
1631 }
1632
clone(MemoryPool * pool) const1633 ObjCMethodPrototypeAST *ObjCMethodPrototypeAST::clone(MemoryPool *pool) const
1634 {
1635 ObjCMethodPrototypeAST *ast = new (pool) ObjCMethodPrototypeAST;
1636 ast->method_type_token = method_type_token;
1637 if (type_name)
1638 ast->type_name = type_name->clone(pool);
1639 if (selector)
1640 ast->selector = selector->clone(pool);
1641 for (ObjCMessageArgumentDeclarationListAST *iter = argument_list, **ast_iter = &ast->argument_list;
1642 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1643 *ast_iter = new (pool) ObjCMessageArgumentDeclarationListAST((iter->value) ? iter->value->clone(pool) : nullptr);
1644 ast->dot_dot_dot_token = dot_dot_dot_token;
1645 for (SpecifierListAST *iter = attribute_list, **ast_iter = &ast->attribute_list;
1646 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1647 *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : nullptr);
1648 return ast;
1649 }
1650
clone(MemoryPool * pool) const1651 ObjCMethodDeclarationAST *ObjCMethodDeclarationAST::clone(MemoryPool *pool) const
1652 {
1653 ObjCMethodDeclarationAST *ast = new (pool) ObjCMethodDeclarationAST;
1654 if (method_prototype)
1655 ast->method_prototype = method_prototype->clone(pool);
1656 if (function_body)
1657 ast->function_body = function_body->clone(pool);
1658 ast->semicolon_token = semicolon_token;
1659 return ast;
1660 }
1661
clone(MemoryPool * pool) const1662 ObjCSynthesizedPropertyAST *ObjCSynthesizedPropertyAST::clone(MemoryPool *pool) const
1663 {
1664 ObjCSynthesizedPropertyAST *ast = new (pool) ObjCSynthesizedPropertyAST;
1665 ast->property_identifier_token = property_identifier_token;
1666 ast->equals_token = equals_token;
1667 ast->alias_identifier_token = alias_identifier_token;
1668 return ast;
1669 }
1670
clone(MemoryPool * pool) const1671 ObjCSynthesizedPropertiesDeclarationAST *ObjCSynthesizedPropertiesDeclarationAST::clone(MemoryPool *pool) const
1672 {
1673 ObjCSynthesizedPropertiesDeclarationAST *ast = new (pool) ObjCSynthesizedPropertiesDeclarationAST;
1674 ast->synthesized_token = synthesized_token;
1675 for (ObjCSynthesizedPropertyListAST *iter = property_identifier_list, **ast_iter = &ast->property_identifier_list;
1676 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1677 *ast_iter = new (pool) ObjCSynthesizedPropertyListAST((iter->value) ? iter->value->clone(pool) : nullptr);
1678 ast->semicolon_token = semicolon_token;
1679 return ast;
1680 }
1681
clone(MemoryPool * pool) const1682 ObjCDynamicPropertiesDeclarationAST *ObjCDynamicPropertiesDeclarationAST::clone(MemoryPool *pool) const
1683 {
1684 ObjCDynamicPropertiesDeclarationAST *ast = new (pool) ObjCDynamicPropertiesDeclarationAST;
1685 ast->dynamic_token = dynamic_token;
1686 for (NameListAST *iter = property_identifier_list, **ast_iter = &ast->property_identifier_list;
1687 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1688 *ast_iter = new (pool) NameListAST((iter->value) ? iter->value->clone(pool) : nullptr);
1689 ast->semicolon_token = semicolon_token;
1690 return ast;
1691 }
1692
clone(MemoryPool * pool) const1693 ObjCFastEnumerationAST *ObjCFastEnumerationAST::clone(MemoryPool *pool) const
1694 {
1695 ObjCFastEnumerationAST *ast = new (pool) ObjCFastEnumerationAST;
1696 ast->for_token = for_token;
1697 ast->lparen_token = lparen_token;
1698 for (SpecifierListAST *iter = type_specifier_list, **ast_iter = &ast->type_specifier_list;
1699 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1700 *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : nullptr);
1701 if (declarator)
1702 ast->declarator = declarator->clone(pool);
1703 if (initializer)
1704 ast->initializer = initializer->clone(pool);
1705 ast->in_token = in_token;
1706 if (fast_enumeratable_expression)
1707 ast->fast_enumeratable_expression = fast_enumeratable_expression->clone(pool);
1708 ast->rparen_token = rparen_token;
1709 if (statement)
1710 ast->statement = statement->clone(pool);
1711 return ast;
1712 }
1713
clone(MemoryPool * pool) const1714 ObjCSynchronizedStatementAST *ObjCSynchronizedStatementAST::clone(MemoryPool *pool) const
1715 {
1716 ObjCSynchronizedStatementAST *ast = new (pool) ObjCSynchronizedStatementAST;
1717 ast->synchronized_token = synchronized_token;
1718 ast->lparen_token = lparen_token;
1719 if (synchronized_object)
1720 ast->synchronized_object = synchronized_object->clone(pool);
1721 ast->rparen_token = rparen_token;
1722 if (statement)
1723 ast->statement = statement->clone(pool);
1724 return ast;
1725 }
1726
clone(MemoryPool * pool) const1727 LambdaExpressionAST *LambdaExpressionAST::clone(MemoryPool *pool) const
1728 {
1729 LambdaExpressionAST *ast = new (pool) LambdaExpressionAST;
1730 if (lambda_introducer)
1731 ast->lambda_introducer = lambda_introducer->clone(pool);
1732 if (lambda_declarator)
1733 ast->lambda_declarator = lambda_declarator->clone(pool);
1734 if (statement)
1735 ast->statement = statement->clone(pool);
1736 return ast;
1737 }
1738
clone(MemoryPool * pool) const1739 LambdaIntroducerAST *LambdaIntroducerAST::clone(MemoryPool *pool) const
1740 {
1741 LambdaIntroducerAST *ast = new (pool) LambdaIntroducerAST;
1742 ast->lbracket_token = lbracket_token;
1743 if (lambda_capture)
1744 ast->lambda_capture = lambda_capture->clone(pool);
1745 ast->rbracket_token = rbracket_token;
1746 return ast;
1747 }
1748
clone(MemoryPool * pool) const1749 LambdaCaptureAST *LambdaCaptureAST::clone(MemoryPool *pool) const
1750 {
1751 LambdaCaptureAST *ast = new (pool) LambdaCaptureAST;
1752 ast->default_capture_token = default_capture_token;
1753 for (CaptureListAST *iter = capture_list, **ast_iter = &ast->capture_list;
1754 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1755 *ast_iter = new (pool) CaptureListAST((iter->value) ? iter->value->clone(pool) : nullptr);
1756 return ast;
1757 }
1758
clone(MemoryPool * pool) const1759 CaptureAST *CaptureAST::clone(MemoryPool *pool) const
1760 {
1761 CaptureAST *ast = new (pool) CaptureAST;
1762 ast->amper_token = amper_token;
1763 if (identifier)
1764 ast->identifier = identifier->clone(pool);
1765 return ast;
1766 }
1767
clone(MemoryPool * pool) const1768 LambdaDeclaratorAST *LambdaDeclaratorAST::clone(MemoryPool *pool) const
1769 {
1770 LambdaDeclaratorAST *ast = new (pool) LambdaDeclaratorAST;
1771 ast->lparen_token = lparen_token;
1772 if (parameter_declaration_clause)
1773 ast->parameter_declaration_clause = parameter_declaration_clause->clone(pool);
1774 ast->rparen_token = rparen_token;
1775 for (SpecifierListAST *iter = attributes, **ast_iter = &ast->attributes;
1776 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1777 *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : nullptr);
1778 ast->mutable_token = mutable_token;
1779 if (exception_specification)
1780 ast->exception_specification = exception_specification->clone(pool);
1781 if (trailing_return_type)
1782 ast->trailing_return_type = trailing_return_type->clone(pool);
1783 return ast;
1784 }
1785
clone(MemoryPool * pool) const1786 TrailingReturnTypeAST *TrailingReturnTypeAST::clone(MemoryPool *pool) const
1787 {
1788 TrailingReturnTypeAST *ast = new (pool) TrailingReturnTypeAST;
1789 ast->arrow_token = arrow_token;
1790 for (SpecifierListAST *iter = attributes, **ast_iter = &ast->attributes;
1791 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1792 *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : nullptr);
1793 for (SpecifierListAST *iter = type_specifier_list, **ast_iter = &ast->type_specifier_list;
1794 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1795 *ast_iter = new (pool) SpecifierListAST((iter->value) ? iter->value->clone(pool) : nullptr);
1796 if (declarator)
1797 ast->declarator = declarator->clone(pool);
1798 return ast;
1799 }
1800
clone(MemoryPool * pool) const1801 BracedInitializerAST *BracedInitializerAST::clone(MemoryPool *pool) const
1802 {
1803 BracedInitializerAST *ast = new (pool) BracedInitializerAST;
1804 ast->lbrace_token = lbrace_token;
1805 for (ExpressionListAST *iter = expression_list, **ast_iter = &ast->expression_list;
1806 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1807 *ast_iter = new (pool) ExpressionListAST((iter->value) ? iter->value->clone(pool) : nullptr);
1808 ast->comma_token = comma_token;
1809 ast->rbrace_token = rbrace_token;
1810 return ast;
1811 }
1812
clone(MemoryPool * pool) const1813 DotDesignatorAST *DotDesignatorAST::clone(MemoryPool *pool) const
1814 {
1815 DotDesignatorAST *ast = new (pool) DotDesignatorAST;
1816 ast->dot_token = dot_token;
1817 ast->identifier_token = identifier_token;
1818 return ast;
1819 }
1820
clone(MemoryPool * pool) const1821 BracketDesignatorAST *BracketDesignatorAST::clone(MemoryPool *pool) const
1822 {
1823 BracketDesignatorAST *ast = new (pool) BracketDesignatorAST;
1824 ast->lbracket_token = lbracket_token;
1825 if (expression)
1826 ast->expression = expression->clone(pool);
1827 ast->rbracket_token = rbracket_token;
1828 return ast;
1829 }
1830
clone(MemoryPool * pool) const1831 DesignatedInitializerAST *DesignatedInitializerAST::clone(MemoryPool *pool) const
1832 {
1833 DesignatedInitializerAST *ast = new (pool) DesignatedInitializerAST;
1834 for (DesignatorListAST *iter = designator_list, **ast_iter = &ast->designator_list;
1835 iter; iter = iter->next, ast_iter = &(*ast_iter)->next)
1836 *ast_iter = new (pool) DesignatorListAST((iter->value) ? iter->value->clone(pool) : nullptr);
1837 ast->equal_token = equal_token;
1838 if (initializer)
1839 ast->initializer = initializer->clone(pool);
1840 return ast;
1841 }
1842
1843