source: src/AST/Convert.cpp@ 112fe04

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 112fe04 was 112fe04, checked in by Andrew Beach <ajbeach@…>, 7 years ago

Work on ConverterNewToOld, filled in declarations and cleaned up statements.
  • Property mode set to 100644
File size: 39.7 KB
RevLine 
[6d51bd7]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//
[74dbbf6]7// Convert.cpp -- Convert between the new and old syntax trees.
[6d51bd7]8//
9// Author : Thierry Delisle
10// Created On : Thu May 09 15::37::05 2019
[6f8e87d]11// Last Modified By : Andrew Beach
[112fe04]12// Last Modified On : Tue May 21 15:30:00 2019
13// Update Count : 5
[6d51bd7]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"
[172d9342]23#include "AST/TypeSubstitution.hpp"
[6d51bd7]24
25#include "SynTree/Attribute.h"
26#include "SynTree/Declaration.h"
[172d9342]27#include "SynTree/TypeSubstitution.h"
[6d51bd7]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//================================================================================================
[74dbbf6]42class ConverterNewToOld : public ast::Visitor {
[675d816]43 BaseSyntaxNode * node = nullptr;
44
[74dbbf6]45 template<typename T>
[675d816]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 }
[74dbbf6]86 return ret;
87 }
88
[675d816]89public:
90 Declaration * decl( const ast::Decl * declNode ) {
91 return get<Declaration>().accept1( ast::ptr<ast::Decl>( declNode ) );
92 }
[74dbbf6]93
[675d816]94private:
[112fe04]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
[74dbbf6]114 return nullptr;
115 }
116
[112fe04]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
[74dbbf6]131 const ast::DeclWithType * visit( const ast::FunctionDecl * node ) override final {
[112fe04]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 );
[74dbbf6]143 }
144
[112fe04]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 );
[74dbbf6]151 return nullptr;
152 }
153
[112fe04]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 );
[74dbbf6]178 }
179
[112fe04]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 );
[74dbbf6]189 }
190
[112fe04]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;
[74dbbf6]197 return nullptr;
198 }
199
[112fe04]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 );
[74dbbf6]208 }
209
[112fe04]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 );
[74dbbf6]235 }
236
237 const ast::AsmDecl * visit( const ast::AsmDecl * node ) override final {
[112fe04]238 auto decl = new AsmDecl( get<AsmStmt>().accept1( node->stmt ) );
239 declPostamble( decl, node );
[74dbbf6]240 return nullptr;
241 }
242
243 const ast::StaticAssertDecl * visit( const ast::StaticAssertDecl * node ) override final {
[112fe04]244 auto decl = new StaticAssertDecl(
245 get<Expression>().accept1( node->cond ),
246 get<ConstantExpr>().accept1( node->msg )
247 );
248 declPostamble( decl, node );
[74dbbf6]249 return nullptr;
250 }
251
[112fe04]252 const ast::Stmt * stmtPostamble( Statement * stmt, const ast::Stmt * node ) {
[675d816]253 stmt->location = node->location;
254 stmt->labels = makeLabelL( stmt, node->labels );
255 this->node = stmt;
[74dbbf6]256 return nullptr;
257 }
258
[112fe04]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
[74dbbf6]265 const ast::Stmt * visit( const ast::ExprStmt * node ) override final {
[675d816]266 auto stmt = new ExprStmt( get<Expression>().accept1( node->expr ) );
[112fe04]267 return stmtPostamble( stmt, node );
[74dbbf6]268 }
269
270 const ast::Stmt * visit( const ast::AsmStmt * node ) override final {
[675d816]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 );
[112fe04]279 return stmtPostamble( stmt, node );
[74dbbf6]280 }
281
282 const ast::Stmt * visit( const ast::DirectiveStmt * node ) override final {
[675d816]283 auto stmt = new DirectiveStmt( node->directive );
[112fe04]284 return stmtPostamble( stmt, node );
[74dbbf6]285 }
286
287 const ast::Stmt * visit( const ast::IfStmt * node ) override final {
[675d816]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 );
[112fe04]294 return stmtPostamble( stmt, node );
[74dbbf6]295 }
296
[675d816]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 );
[112fe04]302 return stmtPostamble( stmt, node );
[74dbbf6]303 }
304
[675d816]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 );
[112fe04]311 return stmtPostamble( stmt, node );
[74dbbf6]312 }
313
[675d816]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 );
[112fe04]322 return stmtPostamble( stmt, node );
[74dbbf6]323 }
324
[675d816]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 );
[112fe04]332 return stmtPostamble( stmt, node );
[74dbbf6]333 }
334
335 const ast::Stmt * visit( const ast::BranchStmt * node ) override final {
[675d816]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 }
[112fe04]361 return stmtPostamble( stmt, node );
[74dbbf6]362 }
363
364 const ast::Stmt * visit( const ast::ReturnStmt * node ) override final {
[675d816]365 auto stmt = new ReturnStmt( get<Expression>().accept1( node->expr ) );
[112fe04]366 return stmtPostamble( stmt, node );
[74dbbf6]367 }
368
369 const ast::Stmt * visit( const ast::ThrowStmt * node ) override final {
[675d816]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 );
[112fe04]386 return stmtPostamble( stmt, node );
[74dbbf6]387 }
388
389 const ast::Stmt * visit( const ast::TryStmt * node ) override final {
[675d816]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 );
[112fe04]396 return stmtPostamble( stmt, node );
[74dbbf6]397 }
398
399 const ast::Stmt * visit( const ast::CatchStmt * node ) override final {
[675d816]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 );
[112fe04]417 return stmtPostamble( stmt, node );
[74dbbf6]418 }
419
420 const ast::Stmt * visit( const ast::FinallyStmt * node ) override final {
[675d816]421 auto stmt = new FinallyStmt( get<CompoundStmt>().accept1( node->body ) );
[112fe04]422 return stmtPostamble( stmt, node );
[74dbbf6]423 }
424
425 const ast::Stmt * visit( const ast::WaitForStmt * node ) override final {
[675d816]426 auto stmt = new WaitForStmt;
427 stmt->clauses.reserve( node->clauses.size() );
428 for ( auto clause : node->clauses ) {
429 stmt->clauses.push_back({{
[e0016a5]430 get<Expression>().accept1( clause.target.func ),
431 get<Expression>().acceptL( clause.target.args ),
[675d816]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 };
[112fe04]446 return stmtPostamble( stmt, node );
[74dbbf6]447 }
448
449 const ast::Stmt * visit( const ast::WithStmt * node ) override final {
[675d816]450 auto stmt = new WithStmt(
451 get<Expression>().acceptL( node->exprs ),
452 get<Statement>().accept1( node->stmt )
453 );
[112fe04]454 return stmtPostamble( stmt, node );
[74dbbf6]455 }
456
457 const ast::NullStmt * visit( const ast::NullStmt * node ) override final {
[675d816]458 auto stmt = new NullStmt();
[112fe04]459 stmtPostamble( stmt, node );
[74dbbf6]460 return nullptr;
461 }
462
463 const ast::Stmt * visit( const ast::DeclStmt * node ) override final {
[675d816]464 auto stmt = new DeclStmt( get<Declaration>().accept1( node->decl ) );
[112fe04]465 return stmtPostamble( stmt, node );
[74dbbf6]466 }
467
468 const ast::Stmt * visit( const ast::ImplicitCtorDtorStmt * node ) override final {
469 (void)node;
470 return nullptr;
471 }
472
[19e567dd]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
[74dbbf6]528 const ast::Expr * visit( const ast::ApplicationExpr * node ) override final {
[19e567dd]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;
[74dbbf6]536 return nullptr;
537 }
538
539 const ast::Expr * visit( const ast::UntypedExpr * node ) override final {
[19e567dd]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;
[74dbbf6]547 return nullptr;
548 }
549
550 const ast::Expr * visit( const ast::NameExpr * node ) override final {
[19e567dd]551 auto expr = visitBaseExpr( node,
552 new NameExpr(
553 node->name
554 )
555 );
556 this->node = expr;
[74dbbf6]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 }
[6d51bd7]849};
850
[74dbbf6]851std::list< Declaration * > convert( std::list< ast::ptr< ast::Decl > > && translationUnit ) {
852 ConverterNewToOld c;
853 std::list< Declaration * > decls;
854 for(auto d : translationUnit) {
[675d816]855 decls.emplace_back( c.decl( d ) );
[74dbbf6]856 delete d;
857 }
858 return decls;
[6d51bd7]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
[6f8e87d]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
[6d51bd7]904 template<template <class...> class C>
905 C<ast::Label> make_labels(C<Label> olds) {
906 C<ast::Label> ret;
[6f8e87d]907 for (auto oldn : olds) {
908 ret.push_back( make_label( &oldn ) );
[6d51bd7]909 }
910 return ret;
911 }
912
[6f8e87d]913# define GET_LABELS_V(labels) \
914 to<std::vector>::from( make_labels( std::move( labels ) ) )
915
916 // Now all the visit functions:
917
[6d51bd7]918 virtual void visit( ObjectDecl * old ) override final {
919 auto decl = new ast::ObjectDecl(
920 old->location,
921 old->name,
[d66e7b7]922 GET_ACCEPT_1(type, Type),
923 GET_ACCEPT_1(init, Init),
[6d51bd7]924 { old->get_storageClasses().val },
925 { old->linkage.val },
[d66e7b7]926 GET_ACCEPT_1(bitfieldWidth, Expr),
927 GET_ACCEPT_V(attributes, Attribute),
[6d51bd7]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,
[d66e7b7]948 GET_ACCEPT_V(attributes, Attribute),
[6d51bd7]949 { old->linkage.val }
950 );
[d66e7b7]951 decl->parent = GET_ACCEPT_1(parent, AggregateDecl);
[6d51bd7]952 decl->body = old->body;
[d66e7b7]953 decl->params = GET_ACCEPT_V(parameters, TypeDecl);
954 decl->members = GET_ACCEPT_V(members, Decl);
[6d51bd7]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,
[d66e7b7]966 GET_ACCEPT_V(attributes, Attribute),
[6d51bd7]967 { old->linkage.val }
968 );
[d66e7b7]969 decl->parent = GET_ACCEPT_1(parent, AggregateDecl);
[6d51bd7]970 decl->body = old->body;
[d66e7b7]971 decl->params = GET_ACCEPT_V(parameters, TypeDecl);
972 decl->members = GET_ACCEPT_V(members, Decl);
[6d51bd7]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,
[d66e7b7]984 GET_ACCEPT_V(attributes, Attribute),
[6d51bd7]985 { old->linkage.val }
986 );
[d66e7b7]987 decl->parent = GET_ACCEPT_1(parent, AggregateDecl);
[6d51bd7]988 decl->body = old->body;
[d66e7b7]989 decl->params = GET_ACCEPT_V(parameters, TypeDecl);
990 decl->members = GET_ACCEPT_V(members, Decl);
[6d51bd7]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,
[d66e7b7]1002 GET_ACCEPT_V(attributes, Attribute),
[6d51bd7]1003 { old->linkage.val }
1004 );
[d66e7b7]1005 decl->parent = GET_ACCEPT_1(parent, AggregateDecl);
[6d51bd7]1006 decl->body = old->body;
[d66e7b7]1007 decl->params = GET_ACCEPT_V(parameters, TypeDecl);
1008 decl->members = GET_ACCEPT_V(members, Decl);
[6d51bd7]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 },
[d66e7b7]1025 GET_ACCEPT_1(base, Type),
[6d51bd7]1026 { old->linkage.val }
1027 );
[d66e7b7]1028 decl->assertions = GET_ACCEPT_V(assertions, DeclWithType);
1029 decl->params = GET_ACCEPT_V(parameters, TypeDecl);
[6d51bd7]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,
[d66e7b7]1048 to<std::list>::from( GET_ACCEPT_V(kids, Stmt) ),
1049 GET_LABELS_V(old->labels)
[6d51bd7]1050 );
1051
1052 this->node = stmt;
1053 }
1054
1055 virtual void visit( ExprStmt * old ) override final {
[6f8e87d]1056 this->node = new ast::ExprStmt(
[6d51bd7]1057 old->location,
[6f8e87d]1058 GET_ACCEPT_1(expr, Expr),
1059 GET_LABELS_V(old->labels)
[6d51bd7]1060 );
1061 }
1062
[6f8e87d]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 );
[6d51bd7]1074 }
1075
[6f8e87d]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 );
[6d51bd7]1082 }
1083
[6f8e87d]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 );
[6d51bd7]1093 }
1094
[6f8e87d]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 );
[6d51bd7]1102 }
1103
[6f8e87d]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 );
[6d51bd7]1111 }
1112
[6f8e87d]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 );
[6d51bd7]1122 }
1123
[6f8e87d]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 );
[6d51bd7]1133 }
1134
[6f8e87d]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
[d66e7b7]1155 default:
1156 assertf(false, "Invalid BranchStmt::Type %d\n", old->type);
[6f8e87d]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 }
[6d51bd7]1169 }
1170
[6f8e87d]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 );
[6d51bd7]1177 }
1178
[6f8e87d]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;
[d66e7b7]1188 default:
1189 assertf(false, "Invalid ThrowStmt::Kind %d\n", old->kind);
[6f8e87d]1190 }
[6d51bd7]1191
[6f8e87d]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 );
[6d51bd7]1199 }
1200
[6f8e87d]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 );
[6d51bd7]1209 }
1210
[6f8e87d]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;
[d66e7b7]1220 default:
1221 assertf(false, "Invalid CatchStmt::Kind %d\n", old->kind);
[6f8e87d]1222 }
[6d51bd7]1223
[6f8e87d]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 );
[6d51bd7]1232 }
1233
[6f8e87d]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 );
[6d51bd7]1240 }
1241
[6f8e87d]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 );
[6d51bd7]1247
[6f8e87d]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 };
[6d51bd7]1268
[6f8e87d]1269 this->node = stmt;
1270 }
[6d51bd7]1271
[6f8e87d]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 );
[6d51bd7]1279 }
1280
1281 virtual void visit( NullStmt * old ) override final {
[6f8e87d]1282 this->node = new ast::NullStmt(
[6d51bd7]1283 old->location,
[6f8e87d]1284 GET_LABELS_V(old->labels)
[6d51bd7]1285 );
1286 }
1287
[6f8e87d]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 );
[6d51bd7]1294 }
1295
[6f8e87d]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 );
[6d51bd7]1302 }
1303
[172d9342]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 }
[6d51bd7]1312
[172d9342]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 }
[19e567dd]1317
1318 return rslt;
[6d51bd7]1319 }
1320
[e0016a5]1321 void convertInferUnion(ast::Expr::InferUnion &newInferred,
[19e567dd]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 }
[172d9342]1344 }
1345
1346 ast::Expr * visitBaseExpr(Expression * old, ast::Expr * nw) {
[6d51bd7]1347
[172d9342]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 }
[6d51bd7]1356
[19e567dd]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 );
[6d51bd7]1365 }
1366
[19e567dd]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 );
[172d9342]1375 }
[6d51bd7]1376
[172d9342]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 );
[6d51bd7]1384 }
1385
[19e567dd]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 );
[6d51bd7]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 }
[b336af9]1627
1628 virtual void visit( AttrExpr * ) override final {
1629
1630 assert( 0 );
1631 }
[6d51bd7]1632};
1633
[6f8e87d]1634#undef GET_LABELS_V
1635#undef GET_ACCEPT_V
1636#undef GET_ACCEPT_1
1637
[74dbbf6]1638std::list< ast::ptr< ast::Decl > > convert( const std::list< Declaration * > && translationUnit ) {
[6d51bd7]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;
[6f8e87d]1647}
Note: See TracBrowser for help on using the repository browser.