source: src/AST/Convert.cpp@ 461046f

ADT arm-eh ast-experimental cleanup-dtors enum forall-pointer-decay jacob/cs343-translation jenkins-sandbox new-ast new-ast-unique-expr pthread-emulation qualifiedEnum
Last change on this file since 461046f was 112fe04, checked in by Andrew Beach <ajbeach@…>, 6 years ago

Work on ConverterNewToOld, filled in declarations and cleaned up statements.
  • Property mode set to 100644
File size: 39.7 KB
Line 
1//
2// Cforall Version 1.0.0 Copyright (C) 2019 University of Waterloo
3//
4// The contents of this file are covered under the licence agreement in the
5// file "LICENCE" distributed with Cforall.
6//
7// Convert.cpp -- Convert between the new and old syntax trees.
8//
9// Author : Thierry Delisle
10// Created On : Thu May 09 15::37::05 2019
11// Last Modified By : Andrew Beach
12// Last Modified On : Tue May 21 15:30:00 2019
13// Update Count : 5
14//
15
16#include "Convert.hpp"
17
18#include "AST/Attribute.hpp"
19#include "AST/Decl.hpp"
20#include "AST/Expr.hpp"
21#include "AST/Init.hpp"
22#include "AST/Stmt.hpp"
23#include "AST/TypeSubstitution.hpp"
24
25#include "SynTree/Attribute.h"
26#include "SynTree/Declaration.h"
27#include "SynTree/TypeSubstitution.h"
28
29//================================================================================================
30// Utilities
31template<template <class...> class C>
32struct to {
33 template<typename T>
34 static auto from( T && v ) -> C< typename T::value_type > {
35 C< typename T::value_type > l;
36 std::move(std::begin(v), std::end(v), std::back_inserter(l));
37 return l;
38 }
39};
40
41//================================================================================================
42class ConverterNewToOld : public ast::Visitor {
43 BaseSyntaxNode * node = nullptr;
44
45 template<typename T>
46 struct Getter {
47 ConverterNewToOld & visitor;
48
49 template<typename U>
50 T * accept1( const ast::ptr<U> & ptr ) {
51 ptr->accept( visitor );
52 T * ret = strict_dynamic_cast< T * >( visitor.node );
53 visitor.node = nullptr;
54 return ret;
55 }
56
57 template<typename U>
58 std::list< T * > acceptL( const U & container ) {
59 std::list< T * > ret;
60 for (auto ptr : container ) {
61 ret.emplace_back( accept1( ptr ) );
62 }
63 return ret;
64 }
65 };
66
67 template<typename T>
68 Getter<T> get() {
69 return Getter<T>{ *this };
70 }
71
72 Label makeLabel(Statement * labelled, const ast::Label& label) {
73 return Label(
74 label.name,
75 labelled,
76 get<Attribute>().acceptL(label.attributes)
77 );
78 }
79
80 template<template <class...> class C>
81 std::list<Label> makeLabelL(Statement * labelled, const C<ast::Label>& labels) {
82 std::list<Label> ret;
83 for (auto label : labels) {
84 ret.push_back( makeLabel(labelled, label) );
85 }
86 return ret;
87 }
88
89public:
90 Declaration * decl( const ast::Decl * declNode ) {
91 return get<Declaration>().accept1( ast::ptr<ast::Decl>( declNode ) );
92 }
93
94private:
95 void declPostamble( Declaration * decl, const ast::Decl * node ) {
96 decl->location = node->location;
97 // name comes from constructor
98 // linkage comes from constructor
99 decl->extension = node->extension;
100 decl->uniqueId = node->uniqueId;
101 // storageClasses comes from constructor
102 this->node = decl;
103 }
104
105 const ast::DeclWithType * declWithTypePostamble (
106 DeclarationWithType * decl, const ast::DeclWithType * node ) {
107 declPostamble( decl, node );
108 decl->mangleName = node->mangleName;
109 decl->scopeLevel = node->scopeLevel;
110 decl->asmName = get<Expression>().accept1( node->asmName );
111 // attributes comes from constructor
112 decl->isDeleted = node->isDeleted;
113 // fs comes from constructor
114 return nullptr;
115 }
116
117 const ast::DeclWithType * visit( const ast::ObjectDecl * node ) override final {
118 auto decl = new ObjectDecl(
119 node->name,
120 Type::StorageClasses( node->storage.val ),
121 LinkageSpec::Spec( node->linkage.val ),
122 get<Expression>().accept1( node->bitfieldWidth ),
123 get<Type>().accept1( node->type ),
124 get<Initializer>().accept1( node->init ),
125 get<Attribute>().acceptL( node->attributes ),
126 Type::FuncSpecifiers( node->funcSpec.val )
127 );
128 return declWithTypePostamble( decl, node );
129 }
130
131 const ast::DeclWithType * visit( const ast::FunctionDecl * node ) override final {
132 auto decl = new FunctionDecl(
133 node->name,
134 Type::StorageClasses( node->storage.val ),
135 LinkageSpec::Spec( node->linkage.val ),
136 get<FunctionType>().accept1( node->type ),
137 get<CompoundStmt>().accept1( node->stmts ),
138 get<Attribute>().acceptL( node->attributes ),
139 Type::FuncSpecifiers( node->funcSpec.val )
140 );
141 decl->withExprs = get<Expression>().acceptL( node->withExprs );
142 return declWithTypePostamble( decl, node );
143 }
144
145 // NamedTypeDecl
146 const ast::Decl * namedTypePostamble( NamedTypeDecl * decl, const ast::NamedTypeDecl * node ) {
147 declPostamble( decl, node );
148 // base comes from constructor
149 decl->parameters = get<TypeDecl>().acceptL( node->params );
150 decl->assertions = get<DeclarationWithType>().acceptL( node->assertions );
151 return nullptr;
152 }
153
154 const ast::Decl * visit( const ast::TypeDecl * node ) override final {
155 TypeDecl::Kind kind;
156 switch (node->kind) {
157 case ast::TypeVar::Dtype:
158 kind = TypeDecl::Dtype;
159 break;
160 case ast::TypeVar::Ftype:
161 kind = TypeDecl::Ftype;
162 break;
163 case ast::TypeVar::Ttype:
164 kind = TypeDecl::Ttype;
165 break;
166 default:
167 assertf(false, "Invalid ast::TypeVar::Kind: %d\n", node->kind);
168 };
169 auto decl = new TypeDecl(
170 node->name,
171 Type::StorageClasses( node->storage.val ),
172 get<Type>().accept1( node->base ),
173 kind,
174 node->sized,
175 get<Type>().accept1( node->init )
176 );
177 return namedTypePostamble( decl, node );
178 }
179
180 const ast::Decl * visit( const ast::TypedefDecl * node ) override final {
181 auto decl = new TypedefDecl(
182 node->name,
183 node->location,
184 Type::StorageClasses( node->storage.val ),
185 get<Type>().accept1( node->base ),
186 LinkageSpec::Spec( node->linkage.val )
187 );
188 return namedTypePostamble( decl, node );
189 }
190
191 const ast::Decl * aggregatePostamble( AggregateDecl * decl, const ast::AggregateDecl * node ) {
192 decl->members = get<Declaration>().acceptL( node->members );
193 decl->parameters = get<TypeDecl>().acceptL( node->params );
194 decl->body = node->body;
195 // attributes come from constructor
196 // TODO: Need caching for: decl->parent = node->parent;
197 return nullptr;
198 }
199
200 const ast::Decl * visit( const ast::StructDecl * node ) override final {
201 auto decl = new StructDecl(
202 node->name,
203 node->kind,
204 get<Attribute>().acceptL( node->attributes ),
205 LinkageSpec::Spec( node->linkage.val )
206 );
207 return aggregatePostamble( decl, node );
208 }
209
210 const ast::Decl * visit( const ast::UnionDecl * node ) override final {
211 auto decl = new UnionDecl(
212 node->name,
213 get<Attribute>().acceptL( node->attributes ),
214 LinkageSpec::Spec( node->linkage.val )
215 );
216 return aggregatePostamble( decl, node );
217 }
218
219 const ast::Decl * visit( const ast::EnumDecl * node ) override final {
220 auto decl = new EnumDecl(
221 node->name,
222 get<Attribute>().acceptL( node->attributes ),
223 LinkageSpec::Spec( node->linkage.val )
224 );
225 return aggregatePostamble( decl, node );
226 }
227
228 const ast::Decl * visit( const ast::TraitDecl * node ) override final {
229 auto decl = new TraitDecl(
230 node->name,
231 {},
232 LinkageSpec::Spec( node->linkage.val )
233 );
234 return aggregatePostamble( decl, node );
235 }
236
237 const ast::AsmDecl * visit( const ast::AsmDecl * node ) override final {
238 auto decl = new AsmDecl( get<AsmStmt>().accept1( node->stmt ) );
239 declPostamble( decl, node );
240 return nullptr;
241 }
242
243 const ast::StaticAssertDecl * visit( const ast::StaticAssertDecl * node ) override final {
244 auto decl = new StaticAssertDecl(
245 get<Expression>().accept1( node->cond ),
246 get<ConstantExpr>().accept1( node->msg )
247 );
248 declPostamble( decl, node );
249 return nullptr;
250 }
251
252 const ast::Stmt * stmtPostamble( Statement * stmt, const ast::Stmt * node ) {
253 stmt->location = node->location;
254 stmt->labels = makeLabelL( stmt, node->labels );
255 this->node = stmt;
256 return nullptr;
257 }
258
259 const ast::CompoundStmt * visit( const ast::CompoundStmt * node ) override final {
260 auto stmt = new CompoundStmt( get<Statement>().acceptL( node->kids ) );
261 stmtPostamble( stmt, node );
262 return nullptr;
263 }
264
265 const ast::Stmt * visit( const ast::ExprStmt * node ) override final {
266 auto stmt = new ExprStmt( get<Expression>().accept1( node->expr ) );
267 return stmtPostamble( stmt, node );
268 }
269
270 const ast::Stmt * visit( const ast::AsmStmt * node ) override final {
271 auto stmt = new AsmStmt(
272 node->isVolatile,
273 get<Expression>().accept1( node->instruction ),
274 get<Expression>().acceptL( node->output ),
275 get<Expression>().acceptL( node->input ),
276 get<ConstantExpr>().acceptL( node->clobber ),
277 makeLabelL( nullptr, node->gotoLabels ) // What are these labelling?
278 );
279 return stmtPostamble( stmt, node );
280 }
281
282 const ast::Stmt * visit( const ast::DirectiveStmt * node ) override final {
283 auto stmt = new DirectiveStmt( node->directive );
284 return stmtPostamble( stmt, node );
285 }
286
287 const ast::Stmt * visit( const ast::IfStmt * node ) override final {
288 auto stmt = new IfStmt(
289 get<Expression>().accept1( node->cond ),
290 get<Statement>().accept1( node->thenPart ),
291 get<Statement>().accept1( node->elsePart ),
292 get<Statement>().acceptL( node->inits )
293 );
294 return stmtPostamble( stmt, node );
295 }
296
297 const ast::Stmt * visit( const ast::SwitchStmt * node ) override final {
298 auto stmt = new SwitchStmt(
299 get<Expression>().accept1( node->cond ),
300 get<Statement>().acceptL( node->stmts )
301 );
302 return stmtPostamble( stmt, node );
303 }
304
305 const ast::Stmt * visit( const ast::CaseStmt * node ) override final {
306 auto stmt = new CaseStmt(
307 get<Expression>().accept1( node->cond ),
308 get<Statement>().acceptL( node->stmts ),
309 node->isDefault()
310 );
311 return stmtPostamble( stmt, node );
312 }
313
314 const ast::Stmt * visit( const ast::WhileStmt * node ) override final {
315 auto inits = get<Statement>().acceptL( node->inits );
316 auto stmt = new WhileStmt(
317 get<Expression>().accept1( node->cond ),
318 get<Statement>().accept1( node->body ),
319 inits,
320 node->isDoWhile
321 );
322 return stmtPostamble( stmt, node );
323 }
324
325 const ast::Stmt * visit( const ast::ForStmt * node ) override final {
326 auto stmt = new ForStmt(
327 get<Statement>().acceptL( node->inits ),
328 get<Expression>().accept1( node->cond ),
329 get<Expression>().accept1( node->inc ),
330 get<Statement>().accept1( node->body )
331 );
332 return stmtPostamble( stmt, node );
333 }
334
335 const ast::Stmt * visit( const ast::BranchStmt * node ) override final {
336 BranchStmt * stmt;
337 if (node->computedTarget) {
338 stmt = new BranchStmt( get<Expression>().accept1( node->computedTarget ),
339 BranchStmt::Goto );
340 } else {
341 BranchStmt::Type type;
342 switch (node->kind) {
343 #define CASE(n) \
344 case ast::BranchStmt::n: \
345 type = BranchStmt::n; \
346 break
347 CASE(Goto);
348 CASE(Break);
349 CASE(Continue);
350 CASE(FallThrough);
351 CASE(FallThroughDefault);
352 #undef CASE
353 default:
354 assertf(false, "Invalid ast::BranchStmt::Kind: %d\n", node->kind);
355 }
356
357 // The labels here are also weird.
358 stmt = new BranchStmt( makeLabel( nullptr, node->originalTarget ), type );
359 stmt->target = makeLabel( stmt, node->target );
360 }
361 return stmtPostamble( stmt, node );
362 }
363
364 const ast::Stmt * visit( const ast::ReturnStmt * node ) override final {
365 auto stmt = new ReturnStmt( get<Expression>().accept1( node->expr ) );
366 return stmtPostamble( stmt, node );
367 }
368
369 const ast::Stmt * visit( const ast::ThrowStmt * node ) override final {
370 ThrowStmt::Kind kind;
371 switch (node->kind) {
372 case ast::ThrowStmt::Terminate:
373 kind = ThrowStmt::Terminate;
374 break;
375 case ast::ThrowStmt::Resume:
376 kind = ThrowStmt::Resume;
377 break;
378 default:
379 assertf(false, "Invalid ast::ThrowStmt::Kind: %d\n", node->kind);
380 }
381 auto stmt = new ThrowStmt(
382 kind,
383 get<Expression>().accept1( node->expr ),
384 get<Expression>().accept1( node->target )
385 );
386 return stmtPostamble( stmt, node );
387 }
388
389 const ast::Stmt * visit( const ast::TryStmt * node ) override final {
390 auto handlers = get<CatchStmt>().acceptL( node->handlers );
391 auto stmt = new TryStmt(
392 get<CompoundStmt>().accept1( node->body ),
393 handlers,
394 get<FinallyStmt>().accept1( node->finally )
395 );
396 return stmtPostamble( stmt, node );
397 }
398
399 const ast::Stmt * visit( const ast::CatchStmt * node ) override final {
400 CatchStmt::Kind kind;
401 switch (node->kind) {
402 case ast::CatchStmt::Terminate:
403 kind = CatchStmt::Terminate;
404 break;
405 case ast::CatchStmt::Resume:
406 kind = CatchStmt::Resume;
407 break;
408 default:
409 assertf(false, "Invalid ast::CatchStmt::Kind: %d\n", node->kind);
410 }
411 auto stmt = new CatchStmt(
412 kind,
413 get<Declaration>().accept1( node->decl ),
414 get<Expression>().accept1( node->cond ),
415 get<Statement>().accept1( node->body )
416 );
417 return stmtPostamble( stmt, node );
418 }
419
420 const ast::Stmt * visit( const ast::FinallyStmt * node ) override final {
421 auto stmt = new FinallyStmt( get<CompoundStmt>().accept1( node->body ) );
422 return stmtPostamble( stmt, node );
423 }
424
425 const ast::Stmt * visit( const ast::WaitForStmt * node ) override final {
426 auto stmt = new WaitForStmt;
427 stmt->clauses.reserve( node->clauses.size() );
428 for ( auto clause : node->clauses ) {
429 stmt->clauses.push_back({{
430 get<Expression>().accept1( clause.target.func ),
431 get<Expression>().acceptL( clause.target.args ),
432 },
433 get<Statement>().accept1( clause.stmt ),
434 get<Expression>().accept1( clause.cond ),
435 });
436 }
437 stmt->timeout = {
438 get<Expression>().accept1( node->timeout.time ),
439 get<Statement>().accept1( node->timeout.stmt ),
440 get<Expression>().accept1( node->timeout.cond ),
441 };
442 stmt->orelse = {
443 get<Statement>().accept1( node->orElse.stmt ),
444 get<Expression>().accept1( node->orElse.cond ),
445 };
446 return stmtPostamble( stmt, node );
447 }
448
449 const ast::Stmt * visit( const ast::WithStmt * node ) override final {
450 auto stmt = new WithStmt(
451 get<Expression>().acceptL( node->exprs ),
452 get<Statement>().accept1( node->stmt )
453 );
454 return stmtPostamble( stmt, node );
455 }
456
457 const ast::NullStmt * visit( const ast::NullStmt * node ) override final {
458 auto stmt = new NullStmt();
459 stmtPostamble( stmt, node );
460 return nullptr;
461 }
462
463 const ast::Stmt * visit( const ast::DeclStmt * node ) override final {
464 auto stmt = new DeclStmt( get<Declaration>().accept1( node->decl ) );
465 return stmtPostamble( stmt, node );
466 }
467
468 const ast::Stmt * visit( const ast::ImplicitCtorDtorStmt * node ) override final {
469 (void)node;
470 return nullptr;
471 }
472
473 TypeSubstitution * convertTypeSubstitution(const ast::TypeSubstitution * src) {
474
475 TypeSubstitution *rslt = new TypeSubstitution();
476
477 for (decltype(src->begin()) src_i = src->begin(); src_i != src->end(); src_i++) {
478 rslt->add( src_i->first,
479 get<Type>().accept1(src_i->second) );
480 }
481
482 for (decltype(src->beginVar()) src_i = src->beginVar(); src_i != src->endVar(); src_i++) {
483 rslt->addVar( src_i->first,
484 get<Expression>().accept1(src_i->second) );
485 }
486
487 return rslt;
488 }
489
490 void convertInferUnion(std::map<UniqueId,ParamEntry> &tgtInferParams,
491 std::vector<UniqueId> &tgtResnSlots,
492 const ast::Expr::InferUnion &srcInferred ) {
493
494 assert( tgtInferParams.empty() );
495 assert( tgtResnSlots.empty() );
496
497 if ( srcInferred.mode == ast::Expr::InferUnion::Params ) {
498 const ast::InferredParams &srcParams = srcInferred.inferParamsConst();
499 for (auto srcParam : srcParams) {
500 tgtInferParams[srcParam.first] = ParamEntry(
501 srcParam.second.decl,
502 get<Type>().accept1(srcParam.second.actualType),
503 get<Type>().accept1(srcParam.second.formalType),
504 get<Expression>().accept1(srcParam.second.expr)
505 );
506 }
507 } else if ( srcInferred.mode == ast::Expr::InferUnion::Slots ) {
508 const ast::ResnSlots &srcSlots = srcInferred.resnSlotsConst();
509 for (auto srcSlot : srcSlots) {
510 tgtResnSlots.push_back(srcSlot);
511 }
512 }
513 }
514
515 Expression * visitBaseExpr(const ast::Expr * src, Expression * tgt) {
516
517 tgt->location = src->location;
518
519 tgt->result = get<Type>().accept1(src->result);
520 tgt->env = convertTypeSubstitution(src->env);
521
522 tgt->extension = src->extension;
523 convertInferUnion(tgt->inferParams, tgt->resnSlots, src->inferred);
524
525 return tgt;
526 }
527
528 const ast::Expr * visit( const ast::ApplicationExpr * node ) override final {
529 auto expr = visitBaseExpr( node,
530 new ApplicationExpr(
531 get<Expression>().accept1(node->func),
532 get<Expression>().acceptL(node->args)
533 )
534 );
535 this->node = expr;
536 return nullptr;
537 }
538
539 const ast::Expr * visit( const ast::UntypedExpr * node ) override final {
540 auto expr = visitBaseExpr( node,
541 new UntypedExpr(
542 get<Expression>().accept1(node->func),
543 get<Expression>().acceptL(node->args)
544 )
545 );
546 this->node = expr;
547 return nullptr;
548 }
549
550 const ast::Expr * visit( const ast::NameExpr * node ) override final {
551 auto expr = visitBaseExpr( node,
552 new NameExpr(
553 node->name
554 )
555 );
556 this->node = expr;
557 return nullptr;
558 }
559
560 const ast::Expr * visit( const ast::AddressExpr * node ) override final {
561 (void)node;
562 return nullptr;
563 }
564
565 const ast::Expr * visit( const ast::LabelAddressExpr * node ) override final {
566 (void)node;
567 return nullptr;
568 }
569
570 const ast::Expr * visit( const ast::CastExpr * node ) override final {
571 (void)node;
572 return nullptr;
573 }
574
575 const ast::Expr * visit( const ast::KeywordCastExpr * node ) override final {
576 (void)node;
577 return nullptr;
578 }
579
580 const ast::Expr * visit( const ast::VirtualCastExpr * node ) override final {
581 (void)node;
582 return nullptr;
583 }
584
585 const ast::Expr * visit( const ast::UntypedMemberExpr * node ) override final {
586 (void)node;
587 return nullptr;
588 }
589
590 const ast::Expr * visit( const ast::MemberExpr * node ) override final {
591 (void)node;
592 return nullptr;
593 }
594
595 const ast::Expr * visit( const ast::VariableExpr * node ) override final {
596 (void)node;
597 return nullptr;
598 }
599
600 const ast::Expr * visit( const ast::ConstantExpr * node ) override final {
601 (void)node;
602 return nullptr;
603 }
604
605 const ast::Expr * visit( const ast::SizeofExpr * node ) override final {
606 (void)node;
607 return nullptr;
608 }
609
610 const ast::Expr * visit( const ast::AlignofExpr * node ) override final {
611 (void)node;
612 return nullptr;
613 }
614
615 const ast::Expr * visit( const ast::UntypedOffsetofExpr * node ) override final {
616 (void)node;
617 return nullptr;
618 }
619
620 const ast::Expr * visit( const ast::OffsetofExpr * node ) override final {
621 (void)node;
622 return nullptr;
623 }
624
625 const ast::Expr * visit( const ast::OffsetPackExpr * node ) override final {
626 (void)node;
627 return nullptr;
628 }
629
630 const ast::Expr * visit( const ast::LogicalExpr * node ) override final {
631 (void)node;
632 return nullptr;
633 }
634
635 const ast::Expr * visit( const ast::ConditionalExpr * node ) override final {
636 (void)node;
637 return nullptr;
638 }
639
640 const ast::Expr * visit( const ast::CommaExpr * node ) override final {
641 (void)node;
642 return nullptr;
643 }
644
645 const ast::Expr * visit( const ast::TypeExpr * node ) override final {
646 (void)node;
647 return nullptr;
648 }
649
650 const ast::Expr * visit( const ast::AsmExpr * node ) override final {
651 (void)node;
652 return nullptr;
653 }
654
655 const ast::Expr * visit( const ast::ImplicitCopyCtorExpr * node ) override final {
656 (void)node;
657 return nullptr;
658 }
659
660 const ast::Expr * visit( const ast::ConstructorExpr * node ) override final {
661 (void)node;
662 return nullptr;
663 }
664
665 const ast::Expr * visit( const ast::CompoundLiteralExpr * node ) override final {
666 (void)node;
667 return nullptr;
668 }
669
670 const ast::Expr * visit( const ast::RangeExpr * node ) override final {
671 (void)node;
672 return nullptr;
673 }
674
675 const ast::Expr * visit( const ast::UntypedTupleExpr * node ) override final {
676 (void)node;
677 return nullptr;
678 }
679
680 const ast::Expr * visit( const ast::TupleExpr * node ) override final {
681 (void)node;
682 return nullptr;
683 }
684
685 const ast::Expr * visit( const ast::TupleIndexExpr * node ) override final {
686 (void)node;
687 return nullptr;
688 }
689
690 const ast::Expr * visit( const ast::TupleAssignExpr * node ) override final {
691 (void)node;
692 return nullptr;
693 }
694
695 const ast::Expr * visit( const ast::StmtExpr * node ) override final {
696 (void)node;
697 return nullptr;
698 }
699
700 const ast::Expr * visit( const ast::UniqueExpr * node ) override final {
701 (void)node;
702 return nullptr;
703 }
704
705 const ast::Expr * visit( const ast::UntypedInitExpr * node ) override final {
706 (void)node;
707 return nullptr;
708 }
709
710 const ast::Expr * visit( const ast::InitExpr * node ) override final {
711 (void)node;
712 return nullptr;
713 }
714
715 const ast::Expr * visit( const ast::DeletedExpr * node ) override final {
716 (void)node;
717 return nullptr;
718 }
719
720 const ast::Expr * visit( const ast::DefaultArgExpr * node ) override final {
721 (void)node;
722 return nullptr;
723 }
724
725 const ast::Expr * visit( const ast::GenericExpr * node ) override final {
726 (void)node;
727 return nullptr;
728 }
729
730 const ast::Type * visit( const ast::VoidType * node ) override final {
731 (void)node;
732 return nullptr;
733 }
734
735 const ast::Type * visit( const ast::BasicType * node ) override final {
736 (void)node;
737 return nullptr;
738 }
739
740 const ast::Type * visit( const ast::PointerType * node ) override final {
741 (void)node;
742 return nullptr;
743 }
744
745 const ast::Type * visit( const ast::ArrayType * node ) override final {
746 (void)node;
747 return nullptr;
748 }
749
750 const ast::Type * visit( const ast::ReferenceType * node ) override final {
751 (void)node;
752 return nullptr;
753 }
754
755 const ast::Type * visit( const ast::QualifiedType * node ) override final {
756 (void)node;
757 return nullptr;
758 }
759
760 const ast::Type * visit( const ast::FunctionType * node ) override final {
761 (void)node;
762 return nullptr;
763 }
764
765 const ast::Type * visit( const ast::StructInstType * node ) override final {
766 (void)node;
767 return nullptr;
768 }
769
770 const ast::Type * visit( const ast::UnionInstType * node ) override final {
771 (void)node;
772 return nullptr;
773 }
774
775 const ast::Type * visit( const ast::EnumInstType * node ) override final {
776 (void)node;
777 return nullptr;
778 }
779
780 const ast::Type * visit( const ast::TraitInstType * node ) override final {
781 (void)node;
782 return nullptr;
783 }
784
785 const ast::Type * visit( const ast::TypeInstType * node ) override final {
786 (void)node;
787 return nullptr;
788 }
789
790 const ast::Type * visit( const ast::TupleType * node ) override final {
791 (void)node;
792 return nullptr;
793 }
794
795 const ast::Type * visit( const ast::TypeofType * node ) override final {
796 (void)node;
797 return nullptr;
798 }
799
800 const ast::Type * visit( const ast::VarArgsType * node ) override final {
801 (void)node;
802 return nullptr;
803 }
804
805 const ast::Type * visit( const ast::ZeroType * node ) override final {
806 (void)node;
807 return nullptr;
808 }
809
810 const ast::Type * visit( const ast::OneType * node ) override final {
811 (void)node;
812 return nullptr;
813 }
814
815 const ast::Type * visit( const ast::GlobalScopeType * node ) override final {
816 (void)node;
817 return nullptr;
818 }
819
820 const ast::Designation * visit( const ast::Designation * node ) override final {
821 (void)node;
822 return nullptr;
823 }
824
825 const ast::Init * visit( const ast::SingleInit * node ) override final {
826 (void)node;
827 return nullptr;
828 }
829
830 const ast::Init * visit( const ast::ListInit * node ) override final {
831 (void)node;
832 return nullptr;
833 }
834
835 const ast::Init * visit( const ast::ConstructorInit * node ) override final {
836 (void)node;
837 return nullptr;
838 }
839
840 const ast::Attribute * visit( const ast::Attribute * node ) override final {
841 (void)node;
842 return nullptr;
843 }
844
845 const ast::TypeSubstitution * visit( const ast::TypeSubstitution * node ) override final {
846 (void)node;
847 return nullptr;
848 }
849};
850
851std::list< Declaration * > convert( std::list< ast::ptr< ast::Decl > > && translationUnit ) {
852 ConverterNewToOld c;
853 std::list< Declaration * > decls;
854 for(auto d : translationUnit) {
855 decls.emplace_back( c.decl( d ) );
856 delete d;
857 }
858 return decls;
859}
860
861//================================================================================================
862
863class ConverterOldToNew : public Visitor {
864public:
865 ast::Decl * decl() {
866 return strict_dynamic_cast< ast::Decl * >( node );
867 }
868private:
869 ast::Node * node;
870
871 // Local Utilities:
872
873 template<typename NewT, typename OldT>
874 NewT * getAccept1( OldT old ) {
875 old->accept(*this);
876 return strict_dynamic_cast< NewT * >( node );
877 }
878
879# define GET_ACCEPT_1(child, type) \
880 getAccept1< ast::type, decltype( old->child ) >( old->child )
881
882 template<typename NewT, typename OldC>
883 std::vector< ast::ptr<NewT> > getAcceptV( OldC& old ) {
884 std::vector< ast::ptr<NewT> > ret;
885 ret.reserve( old.size() );
886 for ( auto a : old ) {
887 a->accept( *this );
888 ret.emplace_back( strict_dynamic_cast< NewT * >(node) );
889 }
890 return ret;
891 }
892
893# define GET_ACCEPT_V(child, type) \
894 getAcceptV< ast::type, decltype( old->child ) >( old->child )
895
896 ast::Label make_label(Label* old) {
897 return ast::Label(
898 old->labelled->location,
899 old->name,
900 GET_ACCEPT_V(attributes, Attribute)
901 );
902 }
903
904 template<template <class...> class C>
905 C<ast::Label> make_labels(C<Label> olds) {
906 C<ast::Label> ret;
907 for (auto oldn : olds) {
908 ret.push_back( make_label( &oldn ) );
909 }
910 return ret;
911 }
912
913# define GET_LABELS_V(labels) \
914 to<std::vector>::from( make_labels( std::move( labels ) ) )
915
916 // Now all the visit functions:
917
918 virtual void visit( ObjectDecl * old ) override final {
919 auto decl = new ast::ObjectDecl(
920 old->location,
921 old->name,
922 GET_ACCEPT_1(type, Type),
923 GET_ACCEPT_1(init, Init),
924 { old->get_storageClasses().val },
925 { old->linkage.val },
926 GET_ACCEPT_1(bitfieldWidth, Expr),
927 GET_ACCEPT_V(attributes, Attribute),
928 { old->get_funcSpec().val }
929 );
930 decl->scopeLevel = old->scopeLevel;
931 decl->mangleName = old->mangleName;
932 decl->isDeleted = old->isDeleted;
933 decl->uniqueId = old->uniqueId;
934 decl->extension = old->extension;
935
936 this->node = decl;
937 }
938
939 virtual void visit( FunctionDecl * ) override final {
940
941 }
942
943 virtual void visit( StructDecl * old ) override final {
944 auto decl = new ast::StructDecl(
945 old->location,
946 old->name,
947 old->kind,
948 GET_ACCEPT_V(attributes, Attribute),
949 { old->linkage.val }
950 );
951 decl->parent = GET_ACCEPT_1(parent, AggregateDecl);
952 decl->body = old->body;
953 decl->params = GET_ACCEPT_V(parameters, TypeDecl);
954 decl->members = GET_ACCEPT_V(members, Decl);
955 decl->extension = old->extension;
956 decl->uniqueId = old->uniqueId;
957 decl->storage = { old->storageClasses.val };
958
959 this->node = decl;
960 }
961
962 virtual void visit( UnionDecl * old ) override final {
963 auto decl = new ast::UnionDecl(
964 old->location,
965 old->name,
966 GET_ACCEPT_V(attributes, Attribute),
967 { old->linkage.val }
968 );
969 decl->parent = GET_ACCEPT_1(parent, AggregateDecl);
970 decl->body = old->body;
971 decl->params = GET_ACCEPT_V(parameters, TypeDecl);
972 decl->members = GET_ACCEPT_V(members, Decl);
973 decl->extension = old->extension;
974 decl->uniqueId = old->uniqueId;
975 decl->storage = { old->storageClasses.val };
976
977 this->node = decl;
978 }
979
980 virtual void visit( EnumDecl * old ) override final {
981 auto decl = new ast::UnionDecl(
982 old->location,
983 old->name,
984 GET_ACCEPT_V(attributes, Attribute),
985 { old->linkage.val }
986 );
987 decl->parent = GET_ACCEPT_1(parent, AggregateDecl);
988 decl->body = old->body;
989 decl->params = GET_ACCEPT_V(parameters, TypeDecl);
990 decl->members = GET_ACCEPT_V(members, Decl);
991 decl->extension = old->extension;
992 decl->uniqueId = old->uniqueId;
993 decl->storage = { old->storageClasses.val };
994
995 this->node = decl;
996 }
997
998 virtual void visit( TraitDecl * old ) override final {
999 auto decl = new ast::UnionDecl(
1000 old->location,
1001 old->name,
1002 GET_ACCEPT_V(attributes, Attribute),
1003 { old->linkage.val }
1004 );
1005 decl->parent = GET_ACCEPT_1(parent, AggregateDecl);
1006 decl->body = old->body;
1007 decl->params = GET_ACCEPT_V(parameters, TypeDecl);
1008 decl->members = GET_ACCEPT_V(members, Decl);
1009 decl->extension = old->extension;
1010 decl->uniqueId = old->uniqueId;
1011 decl->storage = { old->storageClasses.val };
1012
1013 this->node = decl;
1014 }
1015
1016 virtual void visit( TypeDecl * ) override final {
1017
1018 }
1019
1020 virtual void visit( TypedefDecl * old ) override final {
1021 auto decl = new ast::TypedefDecl(
1022 old->location,
1023 old->name,
1024 { old->storageClasses.val },
1025 GET_ACCEPT_1(base, Type),
1026 { old->linkage.val }
1027 );
1028 decl->assertions = GET_ACCEPT_V(assertions, DeclWithType);
1029 decl->params = GET_ACCEPT_V(parameters, TypeDecl);
1030 decl->extension = old->extension;
1031 decl->uniqueId = old->uniqueId;
1032 decl->storage = { old->storageClasses.val };
1033
1034 this->node = decl;
1035 }
1036
1037 virtual void visit( AsmDecl * ) override final {
1038
1039 }
1040
1041 virtual void visit( StaticAssertDecl * ) override final {
1042
1043 }
1044
1045 virtual void visit( CompoundStmt * old ) override final {
1046 auto stmt = new ast::CompoundStmt(
1047 old->location,
1048 to<std::list>::from( GET_ACCEPT_V(kids, Stmt) ),
1049 GET_LABELS_V(old->labels)
1050 );
1051
1052 this->node = stmt;
1053 }
1054
1055 virtual void visit( ExprStmt * old ) override final {
1056 this->node = new ast::ExprStmt(
1057 old->location,
1058 GET_ACCEPT_1(expr, Expr),
1059 GET_LABELS_V(old->labels)
1060 );
1061 }
1062
1063 virtual void visit( AsmStmt * old ) override final {
1064 this->node = new ast::AsmStmt(
1065 old->location,
1066 old->voltile,
1067 GET_ACCEPT_1(instruction, Expr),
1068 GET_ACCEPT_V(output, Expr),
1069 GET_ACCEPT_V(input, Expr),
1070 GET_ACCEPT_V(clobber, ConstantExpr),
1071 GET_LABELS_V(old->gotolabels),
1072 GET_LABELS_V(old->labels)
1073 );
1074 }
1075
1076 virtual void visit( DirectiveStmt * old ) override final {
1077 this->node = new ast::DirectiveStmt(
1078 old->location,
1079 old->directive,
1080 GET_LABELS_V(old->labels)
1081 );
1082 }
1083
1084 virtual void visit( IfStmt * old ) override final {
1085 this->node = new ast::IfStmt(
1086 old->location,
1087 GET_ACCEPT_1(condition, Expr),
1088 GET_ACCEPT_1(thenPart, Stmt),
1089 GET_ACCEPT_1(elsePart, Stmt),
1090 GET_ACCEPT_V(initialization, Stmt),
1091 GET_LABELS_V(old->labels)
1092 );
1093 }
1094
1095 virtual void visit( SwitchStmt * old ) override final {
1096 this->node = new ast::SwitchStmt(
1097 old->location,
1098 GET_ACCEPT_1(condition, Expr),
1099 GET_ACCEPT_V(statements, Stmt),
1100 GET_LABELS_V(old->labels)
1101 );
1102 }
1103
1104 virtual void visit( CaseStmt * old ) override final {
1105 this->node = new ast::CaseStmt(
1106 old->location,
1107 GET_ACCEPT_1(condition, Expr),
1108 GET_ACCEPT_V(stmts, Stmt),
1109 GET_LABELS_V(old->labels)
1110 );
1111 }
1112
1113 virtual void visit( WhileStmt * old ) override final {
1114 this->node = new ast::WhileStmt(
1115 old->location,
1116 GET_ACCEPT_1(condition, Expr),
1117 GET_ACCEPT_1(body, Stmt),
1118 GET_ACCEPT_V(initialization, Stmt),
1119 old->isDoWhile,
1120 GET_LABELS_V(old->labels)
1121 );
1122 }
1123
1124 virtual void visit( ForStmt * old ) override final {
1125 this->node = new ast::ForStmt(
1126 old->location,
1127 GET_ACCEPT_V(initialization, Stmt),
1128 GET_ACCEPT_1(condition, Expr),
1129 GET_ACCEPT_1(increment, Expr),
1130 GET_ACCEPT_1(body, Stmt),
1131 GET_LABELS_V(old->labels)
1132 );
1133 }
1134
1135 virtual void visit( BranchStmt * old ) override final {
1136 if (old->computedTarget) {
1137 this->node = new ast::BranchStmt(
1138 old->location,
1139 GET_ACCEPT_1(computedTarget, Expr),
1140 GET_LABELS_V(old->labels)
1141 );
1142 } else {
1143 ast::BranchStmt::Kind kind;
1144 switch (old->type) {
1145 #define CASE(n) \
1146 case BranchStmt::n: \
1147 kind = ast::BranchStmt::n; \
1148 break
1149 CASE(Goto);
1150 CASE(Break);
1151 CASE(Continue);
1152 CASE(FallThrough);
1153 CASE(FallThroughDefault);
1154 #undef CASE
1155 default:
1156 assertf(false, "Invalid BranchStmt::Type %d\n", old->type);
1157 }
1158
1159 Label label = old->originalTarget;
1160 auto stmt = new ast::BranchStmt(
1161 old->location,
1162 kind,
1163 make_label(&label),
1164 GET_LABELS_V(old->labels)
1165 );
1166 stmt->target = make_label(&old->target);
1167 this->node = stmt;
1168 }
1169 }
1170
1171 virtual void visit( ReturnStmt * old ) override final {
1172 this->node = new ast::ReturnStmt(
1173 old->location,
1174 GET_ACCEPT_1(expr, Expr),
1175 GET_LABELS_V(old->labels)
1176 );
1177 }
1178
1179 virtual void visit( ThrowStmt * old ) override final {
1180 ast::ThrowStmt::Kind kind;
1181 switch (old->kind) {
1182 case ThrowStmt::Terminate:
1183 kind = ast::ThrowStmt::Terminate;
1184 break;
1185 case ThrowStmt::Resume:
1186 kind = ast::ThrowStmt::Resume;
1187 break;
1188 default:
1189 assertf(false, "Invalid ThrowStmt::Kind %d\n", old->kind);
1190 }
1191
1192 this->node = new ast::ThrowStmt(
1193 old->location,
1194 kind,
1195 GET_ACCEPT_1(expr, Expr),
1196 GET_ACCEPT_1(target, Expr),
1197 GET_LABELS_V(old->labels)
1198 );
1199 }
1200
1201 virtual void visit( TryStmt * old ) override final {
1202 this->node = new ast::TryStmt(
1203 old->location,
1204 GET_ACCEPT_1(block, CompoundStmt),
1205 GET_ACCEPT_V(handlers, CatchStmt),
1206 GET_ACCEPT_1(finallyBlock, FinallyStmt),
1207 GET_LABELS_V(old->labels)
1208 );
1209 }
1210
1211 virtual void visit( CatchStmt * old ) override final {
1212 ast::CatchStmt::Kind kind;
1213 switch (old->kind) {
1214 case CatchStmt::Terminate:
1215 kind = ast::CatchStmt::Terminate;
1216 break;
1217 case CatchStmt::Resume:
1218 kind = ast::CatchStmt::Resume;
1219 break;
1220 default:
1221 assertf(false, "Invalid CatchStmt::Kind %d\n", old->kind);
1222 }
1223
1224 this->node = new ast::CatchStmt(
1225 old->location,
1226 kind,
1227 GET_ACCEPT_1(decl, Decl),
1228 GET_ACCEPT_1(cond, Expr),
1229 GET_ACCEPT_1(body, Stmt),
1230 GET_LABELS_V(old->labels)
1231 );
1232 }
1233
1234 virtual void visit( FinallyStmt * old ) override final {
1235 this->node = new ast::FinallyStmt(
1236 old->location,
1237 GET_ACCEPT_1(block, CompoundStmt),
1238 GET_LABELS_V(old->labels)
1239 );
1240 }
1241
1242 virtual void visit( WaitForStmt * old ) override final {
1243 ast::WaitForStmt * stmt = new ast::WaitForStmt(
1244 old->location,
1245 GET_LABELS_V(old->labels)
1246 );
1247
1248 stmt->clauses.reserve( old->clauses.size() );
1249 for (size_t i = 0 ; i < old->clauses.size() ; ++i) {
1250 stmt->clauses.push_back({
1251 ast::WaitForStmt::Target{
1252 GET_ACCEPT_1(clauses[i].target.function, Expr),
1253 GET_ACCEPT_V(clauses[i].target.arguments, Expr)
1254 },
1255 GET_ACCEPT_1(clauses[i].statement, Stmt),
1256 GET_ACCEPT_1(clauses[i].condition, Expr)
1257 });
1258 }
1259 stmt->timeout = {
1260 GET_ACCEPT_1(timeout.time, Expr),
1261 GET_ACCEPT_1(timeout.statement, Stmt),
1262 GET_ACCEPT_1(timeout.condition, Expr),
1263 };
1264 stmt->orElse = {
1265 GET_ACCEPT_1(timeout.statement, Stmt),
1266 GET_ACCEPT_1(timeout.condition, Expr),
1267 };
1268
1269 this->node = stmt;
1270 }
1271
1272 virtual void visit( WithStmt * old ) override final {
1273 this->node = new ast::WithStmt(
1274 old->location,
1275 GET_ACCEPT_V(exprs, Expr),
1276 GET_ACCEPT_1(stmt, Stmt),
1277 GET_LABELS_V(old->labels)
1278 );
1279 }
1280
1281 virtual void visit( NullStmt * old ) override final {
1282 this->node = new ast::NullStmt(
1283 old->location,
1284 GET_LABELS_V(old->labels)
1285 );
1286 }
1287
1288 virtual void visit( DeclStmt * old ) override final {
1289 this->node = new ast::DeclStmt(
1290 old->location,
1291 GET_ACCEPT_1(decl, Decl),
1292 GET_LABELS_V(old->labels)
1293 );
1294 }
1295
1296 virtual void visit( ImplicitCtorDtorStmt * old ) override final {
1297 this->node = new ast::ImplicitCtorDtorStmt(
1298 old->location,
1299 GET_ACCEPT_1(callStmt, Stmt),
1300 GET_LABELS_V(old->labels)
1301 );
1302 }
1303
1304 ast::TypeSubstitution * convertTypeSubstitution(const TypeSubstitution * old) {
1305
1306 ast::TypeSubstitution *rslt = new ast::TypeSubstitution();
1307
1308 for (decltype(old->begin()) old_i = old->begin(); old_i != old->end(); old_i++) {
1309 rslt->add( old_i->first,
1310 getAccept1<ast::Type>(old_i->second) );
1311 }
1312
1313 for (decltype(old->beginVar()) old_i = old->beginVar(); old_i != old->endVar(); old_i++) {
1314 rslt->addVar( old_i->first,
1315 getAccept1<ast::Expr>(old_i->second) );
1316 }
1317
1318 return rslt;
1319 }
1320
1321 void convertInferUnion(ast::Expr::InferUnion &newInferred,
1322 const std::map<UniqueId,ParamEntry> &oldInferParams,
1323 const std::vector<UniqueId> &oldResnSlots) {
1324
1325 assert( oldInferParams.empty() || oldResnSlots.empty() );
1326 assert( newInferred.mode == ast::Expr::InferUnion::Empty );
1327
1328 if ( !oldInferParams.empty() ) {
1329 ast::InferredParams &tgt = newInferred.inferParams();
1330 for (auto old : oldInferParams) {
1331 tgt[old.first] = ast::ParamEntry(
1332 old.second.decl,
1333 getAccept1<ast::Type>(old.second.actualType),
1334 getAccept1<ast::Type>(old.second.formalType),
1335 getAccept1<ast::Expr>(old.second.expr)
1336 );
1337 }
1338 } else if ( !oldResnSlots.empty() ) {
1339 ast::ResnSlots &tgt = newInferred.resnSlots();
1340 for (auto old : oldResnSlots) {
1341 tgt.push_back(old);
1342 }
1343 }
1344 }
1345
1346 ast::Expr * visitBaseExpr(Expression * old, ast::Expr * nw) {
1347
1348 nw->result = GET_ACCEPT_1(result, Type);
1349 nw->env = convertTypeSubstitution(old->env);
1350
1351 nw->extension = old->extension;
1352 convertInferUnion(nw->inferred, old->inferParams, old->resnSlots);
1353
1354 return nw;
1355 }
1356
1357 virtual void visit( ApplicationExpr * old ) override final {
1358 this->node = visitBaseExpr( old,
1359 new ast::ApplicationExpr(
1360 old->location,
1361 GET_ACCEPT_1(function, Expr),
1362 GET_ACCEPT_V(args, Expr)
1363 )
1364 );
1365 }
1366
1367 virtual void visit( UntypedExpr * old ) override final {
1368 this->node = visitBaseExpr( old,
1369 new ast::UntypedExpr(
1370 old->location,
1371 GET_ACCEPT_1(function, Expr),
1372 GET_ACCEPT_V(args, Expr)
1373 )
1374 );
1375 }
1376
1377 virtual void visit( NameExpr * old ) override final {
1378 this->node = visitBaseExpr( old,
1379 new ast::NameExpr(
1380 old->location,
1381 old->get_name()
1382 )
1383 );
1384 }
1385
1386 virtual void visit( CastExpr * old ) override final {
1387 this->node = visitBaseExpr( old,
1388 new ast::CastExpr(
1389 old->location,
1390 nullptr, // cast's "to" type is expr's result type; converted in visitBaseExpr
1391 old->isGenerated ? ast::GeneratedCast : ast::ExplicitCast
1392 )
1393 );
1394 }
1395
1396 virtual void visit( KeywordCastExpr * ) override final {
1397
1398 }
1399
1400 virtual void visit( VirtualCastExpr * ) override final {
1401
1402 }
1403
1404 virtual void visit( AddressExpr * ) override final {
1405
1406 }
1407
1408 virtual void visit( LabelAddressExpr * ) override final {
1409
1410 }
1411
1412 virtual void visit( UntypedMemberExpr * ) override final {
1413
1414 }
1415
1416 virtual void visit( MemberExpr * ) override final {
1417
1418 }
1419
1420 virtual void visit( VariableExpr * ) override final {
1421
1422 }
1423
1424 virtual void visit( ConstantExpr * ) override final {
1425
1426 }
1427
1428 virtual void visit( SizeofExpr * ) override final {
1429
1430 }
1431
1432 virtual void visit( AlignofExpr * ) override final {
1433
1434 }
1435
1436 virtual void visit( UntypedOffsetofExpr * ) override final {
1437
1438 }
1439
1440 virtual void visit( OffsetofExpr * ) override final {
1441
1442 }
1443
1444 virtual void visit( OffsetPackExpr * ) override final {
1445
1446 }
1447
1448 virtual void visit( LogicalExpr * ) override final {
1449
1450 }
1451
1452 virtual void visit( ConditionalExpr * ) override final {
1453
1454 }
1455
1456 virtual void visit( CommaExpr * ) override final {
1457
1458 }
1459
1460 virtual void visit( TypeExpr * ) override final {
1461
1462 }
1463
1464 virtual void visit( AsmExpr * ) override final {
1465
1466 }
1467
1468 virtual void visit( ImplicitCopyCtorExpr * ) override final {
1469
1470 }
1471
1472 virtual void visit( ConstructorExpr * ) override final {
1473
1474 }
1475
1476 virtual void visit( CompoundLiteralExpr * ) override final {
1477
1478 }
1479
1480 virtual void visit( RangeExpr * ) override final {
1481
1482 }
1483
1484 virtual void visit( UntypedTupleExpr * ) override final {
1485
1486 }
1487
1488 virtual void visit( TupleExpr * ) override final {
1489
1490 }
1491
1492 virtual void visit( TupleIndexExpr * ) override final {
1493
1494 }
1495
1496 virtual void visit( TupleAssignExpr * ) override final {
1497
1498 }
1499
1500 virtual void visit( StmtExpr * ) override final {
1501
1502 }
1503
1504 virtual void visit( UniqueExpr * ) override final {
1505
1506 }
1507
1508 virtual void visit( UntypedInitExpr * ) override final {
1509
1510 }
1511
1512 virtual void visit( InitExpr * ) override final {
1513
1514 }
1515
1516 virtual void visit( DeletedExpr * ) override final {
1517
1518 }
1519
1520 virtual void visit( DefaultArgExpr * ) override final {
1521
1522 }
1523
1524 virtual void visit( GenericExpr * ) override final {
1525
1526 }
1527
1528 virtual void visit( VoidType * ) override final {
1529
1530 }
1531
1532 virtual void visit( BasicType * ) override final {
1533
1534 }
1535
1536 virtual void visit( PointerType * ) override final {
1537
1538 }
1539
1540 virtual void visit( ArrayType * ) override final {
1541
1542 }
1543
1544 virtual void visit( ReferenceType * ) override final {
1545
1546 }
1547
1548 virtual void visit( QualifiedType * ) override final {
1549
1550 }
1551
1552 virtual void visit( FunctionType * ) override final {
1553
1554 }
1555
1556 virtual void visit( StructInstType * ) override final {
1557
1558 }
1559
1560 virtual void visit( UnionInstType * ) override final {
1561
1562 }
1563
1564 virtual void visit( EnumInstType * ) override final {
1565
1566 }
1567
1568 virtual void visit( TraitInstType * ) override final {
1569
1570 }
1571
1572 virtual void visit( TypeInstType * ) override final {
1573
1574 }
1575
1576 virtual void visit( TupleType * ) override final {
1577
1578 }
1579
1580 virtual void visit( TypeofType * ) override final {
1581
1582 }
1583
1584 virtual void visit( AttrType * ) override final {
1585
1586 }
1587
1588 virtual void visit( VarArgsType * ) override final {
1589
1590 }
1591
1592 virtual void visit( ZeroType * ) override final {
1593
1594 }
1595
1596 virtual void visit( OneType * ) override final {
1597
1598 }
1599
1600 virtual void visit( GlobalScopeType * ) override final {
1601
1602 }
1603
1604 virtual void visit( Designation * ) override final {
1605
1606 }
1607
1608 virtual void visit( SingleInit * ) override final {
1609
1610 }
1611
1612 virtual void visit( ListInit * ) override final {
1613
1614 }
1615
1616 virtual void visit( ConstructorInit * ) override final {
1617
1618 }
1619
1620 virtual void visit( Constant * ) override final {
1621
1622 }
1623
1624 virtual void visit( Attribute * ) override final {
1625
1626 }
1627
1628 virtual void visit( AttrExpr * ) override final {
1629
1630 assert( 0 );
1631 }
1632};
1633
1634#undef GET_LABELS_V
1635#undef GET_ACCEPT_V
1636#undef GET_ACCEPT_1
1637
1638std::list< ast::ptr< ast::Decl > > convert( const std::list< Declaration * > && translationUnit ) {
1639 ConverterOldToNew c;
1640 std::list< ast::ptr< ast::Decl > > decls;
1641 for(auto d : translationUnit) {
1642 d->accept( c );
1643 decls.emplace_back( c.decl() );
1644 delete d;
1645 }
1646 return decls;
1647}
Note: See TracBrowser for help on using the repository browser.