source: src/AST/Convert.cpp@ 1a4323e

ADT arm-eh ast-experimental enum forall-pointer-decay jacob/cs343-translation jenkins-sandbox new-ast new-ast-unique-expr pthread-emulation qualifiedEnum
Last change on this file since 1a4323e was 546e712, checked in by Thierry Delisle <tdelisle@…>, 7 years ago

Fix for 1 bug of N
  • Property mode set to 100644
File size: 72.2 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 : Thu May 06 19:51:00 2019
13// Update Count : 10
14//
15
16#include "Convert.hpp"
17
18#include <unordered_map>
19
20#include "AST/Attribute.hpp"
21#include "AST/Decl.hpp"
22#include "AST/Expr.hpp"
23#include "AST/Init.hpp"
24#include "AST/Stmt.hpp"
25#include "AST/TypeSubstitution.hpp"
26
27#include "SymTab/Autogen.h"
28#include "SynTree/Attribute.h"
29#include "SynTree/Declaration.h"
30#include "SynTree/TypeSubstitution.h"
31
32#include "Validate/FindSpecialDecls.h"
33
34//================================================================================================
35// Utilities
36template<template <class...> class C>
37struct to {
38 template<typename T>
39 static auto from( T && v ) -> C< typename T::value_type > {
40 C< typename T::value_type > l;
41 std::move(std::begin(v), std::end(v), std::back_inserter(l));
42 return l;
43 }
44};
45
46//================================================================================================
47namespace {
48
49// This is to preserve the FindSpecialDecls hack. It does not (and perhaps should not)
50// allow us to use the same stratagy in the new ast.
51ast::Type * sizeType = nullptr;
52ast::FunctionDecl * dereferenceOperator = nullptr;
53ast::StructDecl * dtorStruct = nullptr;
54ast::FunctionDecl * dtorStructDestroy = nullptr;
55
56}
57
58//================================================================================================
59class ConverterNewToOld : public ast::Visitor {
60 BaseSyntaxNode * node = nullptr;
61 using Cache = std::unordered_map< const ast::Node *, BaseSyntaxNode * >;
62 Cache cache;
63
64 template<typename T>
65 struct Getter {
66 ConverterNewToOld & visitor;
67
68 template<typename U, enum ast::Node::ref_type R>
69 T * accept1( const ast::ptr_base<U, R> & ptr ) {
70 if ( ! ptr ) return nullptr;
71 ptr->accept( visitor );
72 T * ret = strict_dynamic_cast< T * >( visitor.node );
73 visitor.node = nullptr;
74 return ret;
75 }
76
77 template<typename U>
78 std::list< T * > acceptL( const U & container ) {
79 std::list< T * > ret;
80 for ( auto ptr : container ) {
81 ret.emplace_back( accept1( ptr ) );
82 }
83 return ret;
84 }
85 };
86
87 template<typename T>
88 Getter<T> get() {
89 return Getter<T>{ *this };
90 }
91
92 Label makeLabel(Statement * labelled, const ast::Label& label) {
93 return Label(
94 label.name,
95 labelled,
96 get<Attribute>().acceptL(label.attributes)
97 );
98 }
99
100 template<template <class...> class C>
101 std::list<Label> makeLabelL(Statement * labelled, const C<ast::Label>& labels) {
102 std::list<Label> ret;
103 for (auto label : labels) {
104 ret.push_back( makeLabel(labelled, label) );
105 }
106 return ret;
107 }
108
109 /// get new qualifiers from old type
110 Type::Qualifiers cv( const ast::Type * ty ) { return { ty->qualifiers.val }; }
111
112 /// returns true and sets `node` if in cache
113 bool inCache( const ast::Node * node ) {
114 auto it = cache.find( node );
115 if ( it == cache.end() ) return false;
116 this->node = it->second;
117 return true;
118 }
119
120public:
121 Declaration * decl( const ast::Decl * declNode ) {
122 return get<Declaration>().accept1( ast::ptr<ast::Decl>( declNode ) );
123 }
124
125private:
126 void declPostamble( Declaration * decl, const ast::Decl * node ) {
127 decl->location = node->location;
128 // name comes from constructor
129 // linkage comes from constructor
130 decl->extension = node->extension;
131 decl->uniqueId = node->uniqueId;
132 // storageClasses comes from constructor
133 this->node = decl;
134 }
135
136 const ast::DeclWithType * declWithTypePostamble (
137 DeclarationWithType * decl, const ast::DeclWithType * node ) {
138 cache.emplace( node, decl );
139 decl->mangleName = node->mangleName;
140 decl->scopeLevel = node->scopeLevel;
141 decl->asmName = get<Expression>().accept1( node->asmName );
142 // attributes comes from constructor
143 decl->isDeleted = node->isDeleted;
144 // fs comes from constructor
145 declPostamble( decl, node );
146 return nullptr;
147 }
148
149 const ast::DeclWithType * visit( const ast::ObjectDecl * node ) override final {
150 auto&& bfwd = get<Expression>().accept1( node->bitfieldWidth );
151 auto&& type = get<Type>().accept1( node->type );
152 auto&& init = get<Initializer>().accept1( node->init );
153 auto&& attr = get<Attribute>().acceptL( node->attributes );
154 if ( inCache( node ) ) {
155 if(node->name == "tmp") {
156 std::cerr << (void*)node << "(new) in cache " << (void*)this->node << "(old)" << std::endl;
157 }
158 return nullptr;
159 }
160 auto decl = new ObjectDecl(
161 node->name,
162 Type::StorageClasses( node->storage.val ),
163 LinkageSpec::Spec( node->linkage.val ),
164 bfwd,
165 type,
166 init,
167 attr,
168 Type::FuncSpecifiers( node->funcSpec.val )
169 );
170 if(node->name == "tmp") {
171 std::cerr << (void*)node << "(new) created " << (void*)decl << "(old)" << std::endl;
172 }
173 return declWithTypePostamble( decl, node );
174 }
175
176 const ast::DeclWithType * visit( const ast::FunctionDecl * node ) override final {
177 if ( inCache( node ) ) return nullptr;
178 auto decl = new FunctionDecl(
179 node->name,
180 Type::StorageClasses( node->storage.val ),
181 LinkageSpec::Spec( node->linkage.val ),
182 get<FunctionType>().accept1( node->type ),
183 {},
184 get<Attribute>().acceptL( node->attributes ),
185 Type::FuncSpecifiers( node->funcSpec.val )
186 );
187 cache.emplace( node, decl );
188 decl->statements = get<CompoundStmt>().accept1( node->stmts );
189 decl->withExprs = get<Expression>().acceptL( node->withExprs );
190 if ( dereferenceOperator == node ) {
191 Validate::dereferenceOperator = decl;
192 }
193 if ( dtorStructDestroy == node ) {
194 Validate::dtorStructDestroy = decl;
195 }
196 return declWithTypePostamble( decl, node );
197 }
198
199 const ast::Decl * namedTypePostamble( NamedTypeDecl * decl, const ast::NamedTypeDecl * node ) {
200 // base comes from constructor
201 decl->parameters = get<TypeDecl>().acceptL( node->params );
202 decl->assertions = get<DeclarationWithType>().acceptL( node->assertions );
203 declPostamble( decl, node );
204 return nullptr;
205 }
206
207 const ast::Decl * visit( const ast::TypeDecl * node ) override final {
208 if ( inCache( node ) ) return nullptr;
209 auto decl = new TypeDecl(
210 node->name,
211 Type::StorageClasses( node->storage.val ),
212 get<Type>().accept1( node->base ),
213 (TypeDecl::Kind)(unsigned)node->kind,
214 node->sized,
215 get<Type>().accept1( node->init )
216 );
217 cache.emplace( node, decl );
218 return namedTypePostamble( decl, node );
219 }
220
221 const ast::Decl * visit( const ast::TypedefDecl * node ) override final {
222 auto decl = new TypedefDecl(
223 node->name,
224 node->location,
225 Type::StorageClasses( node->storage.val ),
226 get<Type>().accept1( node->base ),
227 LinkageSpec::Spec( node->linkage.val )
228 );
229 return namedTypePostamble( decl, node );
230 }
231
232 const ast::Decl * aggregatePostamble( AggregateDecl * decl, const ast::AggregateDecl * node ) {
233 cache.emplace( node, decl );
234 decl->members = get<Declaration>().acceptL( node->members );
235 decl->parameters = get<TypeDecl>().acceptL( node->params );
236 decl->body = node->body;
237 // attributes come from constructor
238 decl->parent = get<AggregateDecl>().accept1( node->parent );
239 declPostamble( decl, node );
240 return nullptr;
241 }
242
243 const ast::Decl * visit( const ast::StructDecl * node ) override final {
244 if ( inCache( node ) ) return nullptr;
245 auto decl = new StructDecl(
246 node->name,
247 node->kind,
248 get<Attribute>().acceptL( node->attributes ),
249 LinkageSpec::Spec( node->linkage.val )
250 );
251
252 if ( dtorStruct == node ) {
253 Validate::dtorStruct = decl;
254 }
255
256 return aggregatePostamble( decl, node );
257 }
258
259 const ast::Decl * visit( const ast::UnionDecl * node ) override final {
260 if ( inCache( node ) ) return nullptr;
261 auto decl = new UnionDecl(
262 node->name,
263 get<Attribute>().acceptL( node->attributes ),
264 LinkageSpec::Spec( node->linkage.val )
265 );
266 return aggregatePostamble( decl, node );
267 }
268
269 const ast::Decl * visit( const ast::EnumDecl * node ) override final {
270 if ( inCache( node ) ) return nullptr;
271 auto decl = new EnumDecl(
272 node->name,
273 get<Attribute>().acceptL( node->attributes ),
274 LinkageSpec::Spec( node->linkage.val )
275 );
276 return aggregatePostamble( decl, node );
277 }
278
279 const ast::Decl * visit( const ast::TraitDecl * node ) override final {
280 if ( inCache( node ) ) return nullptr;
281 auto decl = new TraitDecl(
282 node->name,
283 {},
284 LinkageSpec::Spec( node->linkage.val )
285 );
286 return aggregatePostamble( decl, node );
287 }
288
289 const ast::AsmDecl * visit( const ast::AsmDecl * node ) override final {
290 auto decl = new AsmDecl( get<AsmStmt>().accept1( node->stmt ) );
291 declPostamble( decl, node );
292 return nullptr;
293 }
294
295 const ast::StaticAssertDecl * visit( const ast::StaticAssertDecl * node ) override final {
296 auto decl = new StaticAssertDecl(
297 get<Expression>().accept1( node->cond ),
298 get<ConstantExpr>().accept1( node->msg )
299 );
300 declPostamble( decl, node );
301 return nullptr;
302 }
303
304 const ast::Stmt * stmtPostamble( Statement * stmt, const ast::Stmt * node ) {
305 cache.emplace( node, stmt );
306 stmt->location = node->location;
307 stmt->labels = makeLabelL( stmt, node->labels );
308 this->node = stmt;
309 return nullptr;
310 }
311
312 const ast::CompoundStmt * visit( const ast::CompoundStmt * node ) override final {
313 if ( inCache( node ) ) return nullptr;
314 auto stmt = new CompoundStmt( get<Statement>().acceptL( node->kids ) );
315 stmtPostamble( stmt, node );
316 return nullptr;
317 }
318
319 const ast::Stmt * visit( const ast::ExprStmt * node ) override final {
320 if ( inCache( node ) ) return nullptr;
321 auto stmt = new ExprStmt( nullptr );
322 cache.emplace( node, stmt );
323 stmt->expr = get<Expression>().accept1( node->expr );
324 return stmtPostamble( stmt, node );
325 }
326
327 const ast::Stmt * visit( const ast::AsmStmt * node ) override final {
328 if ( inCache( node ) ) return nullptr;
329 auto stmt = new AsmStmt(
330 node->isVolatile,
331 get<Expression>().accept1( node->instruction ),
332 get<Expression>().acceptL( node->output ),
333 get<Expression>().acceptL( node->input ),
334 get<ConstantExpr>().acceptL( node->clobber ),
335 makeLabelL( nullptr, node->gotoLabels ) // What are these labelling?
336 );
337 return stmtPostamble( stmt, node );
338 }
339
340 const ast::Stmt * visit( const ast::DirectiveStmt * node ) override final {
341 if ( inCache( node ) ) return nullptr;
342 auto stmt = new DirectiveStmt( node->directive );
343 return stmtPostamble( stmt, node );
344 }
345
346 const ast::Stmt * visit( const ast::IfStmt * node ) override final {
347 if ( inCache( node ) ) return nullptr;
348 auto stmt = new IfStmt(
349 get<Expression>().accept1( node->cond ),
350 get<Statement>().accept1( node->thenPart ),
351 get<Statement>().accept1( node->elsePart ),
352 get<Statement>().acceptL( node->inits )
353 );
354 return stmtPostamble( stmt, node );
355 }
356
357 const ast::Stmt * visit( const ast::SwitchStmt * node ) override final {
358 if ( inCache( node ) ) return nullptr;
359 auto stmt = new SwitchStmt(
360 get<Expression>().accept1( node->cond ),
361 get<Statement>().acceptL( node->stmts )
362 );
363 return stmtPostamble( stmt, node );
364 }
365
366 const ast::Stmt * visit( const ast::CaseStmt * node ) override final {
367 if ( inCache( node ) ) return nullptr;
368 auto stmt = new CaseStmt(
369 get<Expression>().accept1( node->cond ),
370 get<Statement>().acceptL( node->stmts ),
371 node->isDefault()
372 );
373 return stmtPostamble( stmt, node );
374 }
375
376 const ast::Stmt * visit( const ast::WhileStmt * node ) override final {
377 if ( inCache( node ) ) return nullptr;
378 auto inits = get<Statement>().acceptL( node->inits );
379 auto stmt = new WhileStmt(
380 get<Expression>().accept1( node->cond ),
381 get<Statement>().accept1( node->body ),
382 inits,
383 node->isDoWhile
384 );
385 return stmtPostamble( stmt, node );
386 }
387
388 const ast::Stmt * visit( const ast::ForStmt * node ) override final {
389 if ( inCache( node ) ) return nullptr;
390 auto stmt = new ForStmt(
391 get<Statement>().acceptL( node->inits ),
392 get<Expression>().accept1( node->cond ),
393 get<Expression>().accept1( node->inc ),
394 get<Statement>().accept1( node->body )
395 );
396 return stmtPostamble( stmt, node );
397 }
398
399 const ast::Stmt * visit( const ast::BranchStmt * node ) override final {
400 if ( inCache( node ) ) return nullptr;
401 BranchStmt * stmt;
402 if (node->computedTarget) {
403 stmt = new BranchStmt( get<Expression>().accept1( node->computedTarget ),
404 BranchStmt::Goto );
405 } else {
406 BranchStmt::Type type;
407 switch (node->kind) {
408 #define CASE(n) \
409 case ast::BranchStmt::n: \
410 type = BranchStmt::n; \
411 break
412 CASE(Goto);
413 CASE(Break);
414 CASE(Continue);
415 CASE(FallThrough);
416 CASE(FallThroughDefault);
417 #undef CASE
418 default:
419 assertf(false, "Invalid ast::BranchStmt::Kind: %d\n", node->kind);
420 }
421
422 // The labels here are also weird.
423 stmt = new BranchStmt( makeLabel( nullptr, node->originalTarget ), type );
424 stmt->target = makeLabel( stmt, node->target );
425 }
426 return stmtPostamble( stmt, node );
427 }
428
429 const ast::Stmt * visit( const ast::ReturnStmt * node ) override final {
430 if ( inCache( node ) ) return nullptr;
431 auto stmt = new ReturnStmt( get<Expression>().accept1( node->expr ) );
432 return stmtPostamble( stmt, node );
433 }
434
435 const ast::Stmt * visit( const ast::ThrowStmt * node ) override final {
436 if ( inCache( node ) ) return nullptr;
437 ThrowStmt::Kind kind;
438 switch (node->kind) {
439 case ast::ExceptionKind::Terminate:
440 kind = ThrowStmt::Terminate;
441 break;
442 case ast::ExceptionKind::Resume:
443 kind = ThrowStmt::Resume;
444 break;
445 default:
446 assertf(false, "Invalid ast::ThrowStmt::Kind: %d\n", node->kind);
447 }
448 auto stmt = new ThrowStmt(
449 kind,
450 get<Expression>().accept1( node->expr ),
451 get<Expression>().accept1( node->target )
452 );
453 return stmtPostamble( stmt, node );
454 }
455
456 const ast::Stmt * visit( const ast::TryStmt * node ) override final {
457 if ( inCache( node ) ) return nullptr;
458 auto handlers = get<CatchStmt>().acceptL( node->handlers );
459 auto stmt = new TryStmt(
460 get<CompoundStmt>().accept1( node->body ),
461 handlers,
462 get<FinallyStmt>().accept1( node->finally )
463 );
464 return stmtPostamble( stmt, node );
465 }
466
467 const ast::Stmt * visit( const ast::CatchStmt * node ) override final {
468 if ( inCache( node ) ) return nullptr;
469 CatchStmt::Kind kind;
470 switch (node->kind) {
471 case ast::ExceptionKind::Terminate:
472 kind = CatchStmt::Terminate;
473 break;
474 case ast::ExceptionKind::Resume:
475 kind = CatchStmt::Resume;
476 break;
477 default:
478 assertf(false, "Invalid ast::CatchStmt::Kind: %d\n", node->kind);
479 }
480 auto stmt = new CatchStmt(
481 kind,
482 get<Declaration>().accept1( node->decl ),
483 get<Expression>().accept1( node->cond ),
484 get<Statement>().accept1( node->body )
485 );
486 return stmtPostamble( stmt, node );
487 }
488
489 const ast::Stmt * visit( const ast::FinallyStmt * node ) override final {
490 if ( inCache( node ) ) return nullptr;
491 auto stmt = new FinallyStmt( get<CompoundStmt>().accept1( node->body ) );
492 return stmtPostamble( stmt, node );
493 }
494
495 const ast::Stmt * visit( const ast::WaitForStmt * node ) override final {
496 if ( inCache( node ) ) return nullptr;
497 auto stmt = new WaitForStmt;
498 stmt->clauses.reserve( node->clauses.size() );
499 for ( auto clause : node->clauses ) {
500 stmt->clauses.push_back({{
501 get<Expression>().accept1( clause.target.func ),
502 get<Expression>().acceptL( clause.target.args ),
503 },
504 get<Statement>().accept1( clause.stmt ),
505 get<Expression>().accept1( clause.cond ),
506 });
507 }
508 stmt->timeout = {
509 get<Expression>().accept1( node->timeout.time ),
510 get<Statement>().accept1( node->timeout.stmt ),
511 get<Expression>().accept1( node->timeout.cond ),
512 };
513 stmt->orelse = {
514 get<Statement>().accept1( node->orElse.stmt ),
515 get<Expression>().accept1( node->orElse.cond ),
516 };
517 return stmtPostamble( stmt, node );
518 }
519
520 const ast::Stmt * visit( const ast::WithStmt * node ) override final {
521 if ( inCache( node ) ) return nullptr;
522 auto stmt = new WithStmt(
523 get<Expression>().acceptL( node->exprs ),
524 get<Statement>().accept1( node->stmt )
525 );
526 return stmtPostamble( stmt, node );
527 }
528
529 const ast::NullStmt * visit( const ast::NullStmt * node ) override final {
530 if ( inCache( node ) ) return nullptr;
531 auto stmt = new NullStmt();
532 stmtPostamble( stmt, node );
533 return nullptr;
534 }
535
536 const ast::Stmt * visit( const ast::DeclStmt * node ) override final {
537 if ( inCache( node ) ) return nullptr;
538 auto stmt = new DeclStmt( get<Declaration>().accept1( node->decl ) );
539 return stmtPostamble( stmt, node );
540 }
541
542 const ast::Stmt * visit( const ast::ImplicitCtorDtorStmt * node ) override final {
543 if ( inCache( node ) ) return nullptr;
544 auto stmt = new ImplicitCtorDtorStmt{
545 get<Statement>().accept1( node->callStmt )
546 };
547 return stmtPostamble( stmt, node );
548 }
549
550 TypeSubstitution * convertTypeSubstitution(const ast::TypeSubstitution * src) {
551
552 if (!src) return nullptr;
553
554 TypeSubstitution *rslt = new TypeSubstitution();
555
556 for (decltype(src->begin()) src_i = src->begin(); src_i != src->end(); src_i++) {
557 rslt->add( src_i->first,
558 get<Type>().accept1(src_i->second) );
559 }
560
561 for (decltype(src->beginVar()) src_i = src->beginVar(); src_i != src->endVar(); src_i++) {
562 rslt->addVar( src_i->first,
563 get<Expression>().accept1(src_i->second) );
564 }
565
566 return rslt;
567 }
568
569 void convertInferUnion(std::map<UniqueId,ParamEntry> &tgtInferParams,
570 std::vector<UniqueId> &tgtResnSlots,
571 const ast::Expr::InferUnion &srcInferred ) {
572
573 assert( tgtInferParams.empty() );
574 assert( tgtResnSlots.empty() );
575
576 if ( srcInferred.mode == ast::Expr::InferUnion::Params ) {
577 const ast::InferredParams &srcParams = srcInferred.inferParamsConst();
578 for (auto srcParam : srcParams) {
579 tgtInferParams[srcParam.first] = ParamEntry(
580 srcParam.second.decl,
581 get<Type>().accept1(srcParam.second.actualType),
582 get<Type>().accept1(srcParam.second.formalType),
583 get<Expression>().accept1(srcParam.second.expr)
584 );
585 }
586 } else if ( srcInferred.mode == ast::Expr::InferUnion::Slots ) {
587 const ast::ResnSlots &srcSlots = srcInferred.resnSlotsConst();
588 for (auto srcSlot : srcSlots) {
589 tgtResnSlots.push_back(srcSlot);
590 }
591 }
592 }
593
594 Expression * visitBaseExpr_skipResultType(const ast::Expr * src, Expression * tgt) {
595
596 tgt->location = src->location;
597 tgt->env = convertTypeSubstitution(src->env);
598 tgt->extension = src->extension;
599
600 convertInferUnion(tgt->inferParams, tgt->resnSlots, src->inferred);
601 return tgt;
602 }
603
604 Expression * visitBaseExpr(const ast::Expr * src, Expression * tgt) {
605
606 tgt->result = get<Type>().accept1(src->result);
607 return visitBaseExpr_skipResultType(src, tgt);
608 }
609
610 const ast::Expr * visit( const ast::ApplicationExpr * node ) override final {
611 auto expr = visitBaseExpr( node,
612 new ApplicationExpr(
613 get<Expression>().accept1(node->func),
614 get<Expression>().acceptL(node->args)
615 )
616 );
617 this->node = expr;
618 return nullptr;
619 }
620
621 const ast::Expr * visit( const ast::UntypedExpr * node ) override final {
622 auto expr = visitBaseExpr( node,
623 new UntypedExpr(
624 get<Expression>().accept1(node->func),
625 get<Expression>().acceptL(node->args)
626 )
627 );
628 this->node = expr;
629 return nullptr;
630 }
631
632 const ast::Expr * visit( const ast::NameExpr * node ) override final {
633 auto expr = visitBaseExpr( node,
634 new NameExpr(
635 node->name
636 )
637 );
638 this->node = expr;
639 return nullptr;
640 }
641
642 const ast::Expr * visit( const ast::AddressExpr * node ) override final {
643 auto expr = visitBaseExpr( node,
644 new AddressExpr(
645 get<Expression>().accept1(node->arg)
646 )
647 );
648 this->node = expr;
649 return nullptr;
650 }
651
652 const ast::Expr * visit( const ast::LabelAddressExpr * node ) override final {
653 auto expr = visitBaseExpr( node,
654 new LabelAddressExpr(
655 makeLabel(nullptr, node->arg)
656 )
657 );
658 this->node = expr;
659 return nullptr;
660 }
661
662 const ast::Expr * visit( const ast::CastExpr * node ) override final {
663 auto expr = visitBaseExpr( node,
664 new CastExpr(
665 get<Expression>().accept1(node->arg),
666 (node->isGenerated == ast::GeneratedCast)
667 )
668 );
669 this->node = expr;
670 return nullptr;
671 }
672
673 const ast::Expr * visit( const ast::KeywordCastExpr * node ) override final {
674 KeywordCastExpr::Target castTarget = KeywordCastExpr::NUMBER_OF_TARGETS;
675 switch (node->target) {
676 case ast::KeywordCastExpr::Coroutine:
677 castTarget = KeywordCastExpr::Coroutine;
678 break;
679 case ast::KeywordCastExpr::Thread:
680 castTarget = KeywordCastExpr::Thread;
681 break;
682 case ast::KeywordCastExpr::Monitor:
683 castTarget = KeywordCastExpr::Monitor;
684 break;
685 default:
686 break;
687 }
688 assert ( castTarget < KeywordCastExpr::NUMBER_OF_TARGETS );
689 auto expr = visitBaseExpr( node,
690 new KeywordCastExpr(
691 get<Expression>().accept1(node->arg),
692 castTarget
693 )
694 );
695 this->node = expr;
696 return nullptr;
697 }
698
699 const ast::Expr * visit( const ast::VirtualCastExpr * node ) override final {
700 auto expr = visitBaseExpr_skipResultType( node,
701 new VirtualCastExpr(
702 get<Expression>().accept1(node->arg),
703 get<Type>().accept1(node->result)
704 )
705 );
706 this->node = expr;
707 return nullptr;
708 }
709
710 const ast::Expr * visit( const ast::UntypedMemberExpr * node ) override final {
711 auto expr = visitBaseExpr( node,
712 new UntypedMemberExpr(
713 get<Expression>().accept1(node->member),
714 get<Expression>().accept1(node->aggregate)
715 )
716 );
717 this->node = expr;
718 return nullptr;
719 }
720
721 const ast::Expr * visit( const ast::MemberExpr * node ) override final {
722 auto expr = visitBaseExpr( node,
723 new MemberExpr(
724 get<DeclarationWithType>().accept1(node->member),
725 get<Expression>().accept1(node->aggregate)
726 )
727 );
728 this->node = expr;
729 return nullptr;
730 }
731
732 const ast::Expr * visit( const ast::VariableExpr * node ) override final {
733 auto expr = new VariableExpr();
734 visitBaseExpr( node, expr );
735 expr->var = get<DeclarationWithType>().accept1(node->var);
736 Type * type = expr->var->get_type()->clone();
737 type->set_lvalue( true );
738 expr->set_result( type );
739 this->node = expr;
740 return nullptr;
741 }
742
743 const ast::Expr * visit( const ast::ConstantExpr * node ) override final {
744 ConstantExpr *rslt = nullptr;
745 switch ( node->kind ) {
746 case ast::ConstantExpr::Integer:
747 rslt = new ConstantExpr{Constant{
748 get<Type>().accept1( node->result ),
749 node->rep,
750 (unsigned long long) node->intValue()
751 }};
752 break;
753 case ast::ConstantExpr::FloatingPoint:
754 rslt = new ConstantExpr{Constant{
755 get<Type>().accept1(node->result),
756 node->rep,
757 (double) node->floatValue()
758 }};
759 break;
760 case ast::ConstantExpr::String:
761 rslt = new ConstantExpr{Constant{
762 get<Type>().accept1( node->result ),
763 node->rep,
764 (long long unsigned int)0
765 }};
766 break;
767 }
768 assert(rslt);
769 auto expr = visitBaseExpr( node, rslt );
770 this->node = expr;
771 return nullptr;
772 }
773
774 const ast::Expr * visit( const ast::SizeofExpr * node ) override final {
775 assert (node->expr || node->type);
776 assert (! (node->expr && node->type));
777 SizeofExpr *rslt;
778 if (node->expr) {
779 rslt = new SizeofExpr(
780 get<Expression>().accept1(node->expr)
781 );
782 assert (!rslt->isType);
783 }
784 if (node->type) {
785 rslt = new SizeofExpr(
786 get<Type>().accept1(node->type)
787 );
788 assert (rslt->isType);
789 }
790 auto expr = visitBaseExpr( node, rslt );
791 this->node = expr;
792 return nullptr;
793 }
794
795 const ast::Expr * visit( const ast::AlignofExpr * node ) override final {
796 assert (node->expr || node->type);
797 assert (! (node->expr && node->type));
798 AlignofExpr *rslt;
799 if (node->expr) {
800 rslt = new AlignofExpr(
801 get<Expression>().accept1(node->expr)
802 );
803 assert (!rslt->isType);
804 }
805 if (node->type) {
806 rslt = new AlignofExpr(
807 get<Type>().accept1(node->type)
808 );
809 assert (rslt->isType);
810 }
811 auto expr = visitBaseExpr( node, rslt );
812 this->node = expr;
813 return nullptr;
814 }
815
816 const ast::Expr * visit( const ast::UntypedOffsetofExpr * node ) override final {
817 auto expr = visitBaseExpr( node,
818 new UntypedOffsetofExpr(
819 get<Type>().accept1(node->type),
820 node->member
821 )
822 );
823 this->node = expr;
824 return nullptr;
825 }
826
827 const ast::Expr * visit( const ast::OffsetofExpr * node ) override final {
828 auto expr = visitBaseExpr( node,
829 new OffsetofExpr(
830 get<Type>().accept1(node->type),
831 get<DeclarationWithType>().accept1(node->member)
832 )
833 );
834 this->node = expr;
835 return nullptr;
836 }
837
838 const ast::Expr * visit( const ast::OffsetPackExpr * node ) override final {
839 auto expr = visitBaseExpr( node,
840 new OffsetPackExpr(
841 get<StructInstType>().accept1(node->type)
842 )
843 );
844 this->node = expr;
845 return nullptr;
846 }
847
848 const ast::Expr * visit( const ast::LogicalExpr * node ) override final {
849 assert (node->isAnd == ast::LogicalFlag::AndExpr ||
850 node->isAnd == ast::LogicalFlag::OrExpr );
851 auto expr = visitBaseExpr( node,
852 new LogicalExpr(
853 get<Expression>().accept1(node->arg1),
854 get<Expression>().accept1(node->arg2),
855 (node->isAnd == ast::LogicalFlag::AndExpr)
856 )
857 );
858 this->node = expr;
859 return nullptr;
860 }
861
862 const ast::Expr * visit( const ast::ConditionalExpr * node ) override final {
863 auto expr = visitBaseExpr( node,
864 new ConditionalExpr(
865 get<Expression>().accept1(node->arg1),
866 get<Expression>().accept1(node->arg2),
867 get<Expression>().accept1(node->arg3)
868 )
869 );
870 this->node = expr;
871 return nullptr;
872 }
873
874 const ast::Expr * visit( const ast::CommaExpr * node ) override final {
875 auto expr = visitBaseExpr( node,
876 new CommaExpr(
877 get<Expression>().accept1(node->arg1),
878 get<Expression>().accept1(node->arg2)
879 )
880 );
881 this->node = expr;
882 return nullptr;
883 }
884
885 const ast::Expr * visit( const ast::TypeExpr * node ) override final {
886 auto expr = visitBaseExpr( node,
887 new TypeExpr(
888 get<Type>().accept1(node->type)
889 )
890 );
891 this->node = expr;
892 return nullptr;
893 }
894
895 const ast::Expr * visit( const ast::AsmExpr * node ) override final {
896 auto expr = visitBaseExpr( node,
897 new AsmExpr(
898 get<Expression>().accept1(node->inout),
899 get<Expression>().accept1(node->constraint),
900 get<Expression>().accept1(node->operand)
901 )
902 );
903 this->node = expr;
904 return nullptr;
905 }
906
907 const ast::Expr * visit( const ast::ImplicitCopyCtorExpr * node ) override final {
908 auto rslt = new ImplicitCopyCtorExpr(
909 get<ApplicationExpr>().accept1(node->callExpr)
910 );
911
912 auto expr = visitBaseExpr( node, rslt );
913 this->node = expr;
914 return nullptr;
915 }
916
917 const ast::Expr * visit( const ast::ConstructorExpr * node ) override final {
918 auto expr = visitBaseExpr( node,
919 new ConstructorExpr(
920 get<Expression>().accept1(node->callExpr)
921 )
922 );
923 this->node = expr;
924 return nullptr;
925 }
926
927 const ast::Expr * visit( const ast::CompoundLiteralExpr * node ) override final {
928 auto expr = visitBaseExpr_skipResultType( node,
929 new CompoundLiteralExpr(
930 get<Type>().accept1(node->result),
931 get<Initializer>().accept1(node->init)
932 )
933 );
934 this->node = expr;
935 return nullptr;
936 }
937
938 const ast::Expr * visit( const ast::RangeExpr * node ) override final {
939 auto expr = visitBaseExpr( node,
940 new RangeExpr(
941 get<Expression>().accept1(node->low),
942 get<Expression>().accept1(node->high)
943 )
944 );
945 this->node = expr;
946 return nullptr;
947 }
948
949 const ast::Expr * visit( const ast::UntypedTupleExpr * node ) override final {
950 auto expr = visitBaseExpr( node,
951 new UntypedTupleExpr(
952 get<Expression>().acceptL(node->exprs)
953 )
954 );
955 this->node = expr;
956 return nullptr;
957 }
958
959 const ast::Expr * visit( const ast::TupleExpr * node ) override final {
960 auto expr = visitBaseExpr( node,
961 new UntypedTupleExpr(
962 get<Expression>().acceptL(node->exprs)
963 )
964 );
965 this->node = expr;
966 return nullptr;
967 }
968
969 const ast::Expr * visit( const ast::TupleIndexExpr * node ) override final {
970 auto expr = visitBaseExpr( node,
971 new TupleIndexExpr(
972 get<Expression>().accept1(node->tuple),
973 node->index
974 )
975 );
976 this->node = expr;
977 return nullptr;
978 }
979
980 const ast::Expr * visit( const ast::TupleAssignExpr * node ) override final {
981 auto expr = visitBaseExpr( node,
982 new TupleAssignExpr(
983 get<StmtExpr>().accept1(node->stmtExpr)
984 )
985 );
986 this->node = expr;
987 return nullptr;
988 }
989
990 const ast::Expr * visit( const ast::StmtExpr * node ) override final {
991 auto rslt = new StmtExpr(
992 get<CompoundStmt>().accept1(node->stmts)
993 );
994
995 rslt->returnDecls = get<ObjectDecl>().acceptL(node->returnDecls);
996 rslt->dtors = get<Expression>().acceptL(node->dtors);
997
998 auto expr = visitBaseExpr( node, rslt );
999 this->node = expr;
1000 return nullptr;
1001 }
1002
1003 const ast::Expr * visit( const ast::UniqueExpr * node ) override final {
1004 auto rslt = new UniqueExpr(
1005 get<Expression>().accept1(node->expr)
1006 );
1007
1008 rslt->object = get<ObjectDecl> ().accept1(node->object);
1009 rslt->var = get<VariableExpr>().accept1(node->var);
1010
1011 auto expr = visitBaseExpr( node, rslt );
1012 this->node = expr;
1013 return nullptr;
1014 }
1015
1016 const ast::Expr * visit( const ast::UntypedInitExpr * node ) override final {
1017 std::list<InitAlternative> initAlts;
1018 for (auto ia : node->initAlts) {
1019 initAlts.push_back(InitAlternative(
1020 get<Type> ().accept1(ia.type),
1021 get<Designation>().accept1(ia.designation)
1022 ));
1023 }
1024 auto expr = visitBaseExpr( node,
1025 new UntypedInitExpr(
1026 get<Expression>().accept1(node->expr),
1027 initAlts
1028 )
1029 );
1030 this->node = expr;
1031 return nullptr;
1032 }
1033
1034 const ast::Expr * visit( const ast::InitExpr * node ) override final {
1035 auto expr = visitBaseExpr( node,
1036 new InitExpr(
1037 get<Expression>().accept1(node->expr),
1038 get<Designation>().accept1(node->designation)
1039 )
1040 );
1041 this->node = expr;
1042 return nullptr;
1043 }
1044
1045 const ast::Expr * visit( const ast::DeletedExpr * node ) override final {
1046 auto expr = visitBaseExpr( node,
1047 new DeletedExpr(
1048 get<Expression>().accept1(node->expr),
1049 inCache(node->deleteStmt) ?
1050 this->node :
1051 get<BaseSyntaxNode>().accept1(node->deleteStmt)
1052 )
1053 );
1054 this->node = expr;
1055 return nullptr;
1056 }
1057
1058 const ast::Expr * visit( const ast::DefaultArgExpr * node ) override final {
1059 auto expr = visitBaseExpr( node,
1060 new DefaultArgExpr(
1061 get<Expression>().accept1(node->expr)
1062 )
1063 );
1064 this->node = expr;
1065 return nullptr;
1066 }
1067
1068 const ast::Expr * visit( const ast::GenericExpr * node ) override final {
1069 std::list<GenericExpr::Association> associations;
1070 for (auto association : node->associations) {
1071 associations.push_back(GenericExpr::Association(
1072 get<Type> ().accept1(association.type),
1073 get<Expression>().accept1(association.expr)
1074 ));
1075 }
1076 auto expr = visitBaseExpr( node,
1077 new GenericExpr(
1078 get<Expression>().accept1(node->control),
1079 associations
1080 )
1081 );
1082 this->node = expr;
1083 return nullptr;
1084 }
1085
1086 const ast::Type * visit( const ast::VoidType * node ) override final {
1087 this->node = new VoidType{ cv( node ) };
1088 return nullptr;
1089 }
1090
1091 const ast::Type * visit( const ast::BasicType * node ) override final {
1092 auto type = new BasicType{ cv( node ), (BasicType::Kind)(unsigned)node->kind };
1093 // I believe this should always be a BasicType.
1094 if ( sizeType == node ) {
1095 Validate::SizeType = type;
1096 }
1097 this->node = type;
1098 return nullptr;
1099 }
1100
1101 const ast::Type * visit( const ast::PointerType * node ) override final {
1102 this->node = new PointerType{
1103 cv( node ),
1104 get<Type>().accept1( node->base ),
1105 get<Expression>().accept1( node->dimension ),
1106 (bool)node->isVarLen,
1107 (bool)node->isStatic
1108 };
1109 return nullptr;
1110 }
1111
1112 const ast::Type * visit( const ast::ArrayType * node ) override final {
1113 this->node = new ArrayType{
1114 cv( node ),
1115 get<Type>().accept1( node->base ),
1116 get<Expression>().accept1( node->dimension ),
1117 (bool)node->isVarLen,
1118 (bool)node->isStatic
1119 };
1120 return nullptr;
1121 }
1122
1123 const ast::Type * visit( const ast::ReferenceType * node ) override final {
1124 this->node = new ReferenceType{
1125 cv( node ),
1126 get<Type>().accept1( node->base )
1127 };
1128 return nullptr;
1129 }
1130
1131 const ast::Type * visit( const ast::QualifiedType * node ) override final {
1132 this->node = new QualifiedType{
1133 cv( node ),
1134 get<Type>().accept1( node->parent ),
1135 get<Type>().accept1( node->child )
1136 };
1137 return nullptr;
1138 }
1139
1140 const ast::Type * visit( const ast::FunctionType * node ) override final {
1141 auto ty = new FunctionType {
1142 cv( node ),
1143 (bool)node->isVarArgs
1144 };
1145 ty->returnVals = get<DeclarationWithType>().acceptL( node->returns );
1146 ty->parameters = get<DeclarationWithType>().acceptL( node->params );
1147 ty->forall = get<TypeDecl>().acceptL( node->forall );
1148 this->node = ty;
1149 return nullptr;
1150 }
1151
1152 void postvisit( const ast::ReferenceToType * old, ReferenceToType * ty ) {
1153 ty->forall = get<TypeDecl>().acceptL( old->forall );
1154 ty->parameters = get<Expression>().acceptL( old->params );
1155 ty->hoistType = old->hoistType;
1156 }
1157
1158 const ast::Type * visit( const ast::StructInstType * node ) override final {
1159 StructInstType * ty;
1160 if ( node->base ) {
1161 ty = new StructInstType{
1162 cv( node ),
1163 get<StructDecl>().accept1( node->base ),
1164 get<Attribute>().acceptL( node->attributes )
1165 };
1166 } else {
1167 ty = new StructInstType{
1168 cv( node ),
1169 node->name,
1170 get<Attribute>().acceptL( node->attributes )
1171 };
1172 }
1173 postvisit( node, ty );
1174 this->node = ty;
1175 return nullptr;
1176 }
1177
1178 const ast::Type * visit( const ast::UnionInstType * node ) override final {
1179 UnionInstType * ty;
1180 if ( node->base ) {
1181 ty = new UnionInstType{
1182 cv( node ),
1183 get<UnionDecl>().accept1( node->base ),
1184 get<Attribute>().acceptL( node->attributes )
1185 };
1186 } else {
1187 ty = new UnionInstType{
1188 cv( node ),
1189 node->name,
1190 get<Attribute>().acceptL( node->attributes )
1191 };
1192 }
1193 postvisit( node, ty );
1194 this->node = ty;
1195 return nullptr;
1196 }
1197
1198 const ast::Type * visit( const ast::EnumInstType * node ) override final {
1199 EnumInstType * ty;
1200 if ( node->base ) {
1201 ty = new EnumInstType{
1202 cv( node ),
1203 get<EnumDecl>().accept1( node->base ),
1204 get<Attribute>().acceptL( node->attributes )
1205 };
1206 } else {
1207 ty = new EnumInstType{
1208 cv( node ),
1209 node->name,
1210 get<Attribute>().acceptL( node->attributes )
1211 };
1212 }
1213 postvisit( node, ty );
1214 this->node = ty;
1215 return nullptr;
1216 }
1217
1218 const ast::Type * visit( const ast::TraitInstType * node ) override final {
1219 TraitInstType * ty;
1220 if ( node->base ) {
1221 ty = new TraitInstType{
1222 cv( node ),
1223 get<TraitDecl>().accept1( node->base ),
1224 get<Attribute>().acceptL( node->attributes )
1225 };
1226 } else {
1227 ty = new TraitInstType{
1228 cv( node ),
1229 node->name,
1230 get<Attribute>().acceptL( node->attributes )
1231 };
1232 }
1233 postvisit( node, ty );
1234 this->node = ty;
1235 return nullptr;
1236 }
1237
1238 const ast::Type * visit( const ast::TypeInstType * node ) override final {
1239 TypeInstType * ty;
1240 if ( node->base ) {
1241 ty = new TypeInstType{
1242 cv( node ),
1243 node->name,
1244 get<TypeDecl>().accept1( node->base ),
1245 get<Attribute>().acceptL( node->attributes )
1246 };
1247 } else {
1248 ty = new TypeInstType{
1249 cv( node ),
1250 node->name,
1251 node->kind == ast::TypeVar::Ftype,
1252 get<Attribute>().acceptL( node->attributes )
1253 };
1254 }
1255 postvisit( node, ty );
1256 this->node = ty;
1257 return nullptr;
1258 }
1259
1260 const ast::Type * visit( const ast::TupleType * node ) override final {
1261 this->node = new TupleType{
1262 cv( node ),
1263 get<Type>().acceptL( node->types )
1264 // members generated by TupleType c'tor
1265 };
1266 return nullptr;
1267 }
1268
1269 const ast::Type * visit( const ast::TypeofType * node ) override final {
1270 this->node = new TypeofType{
1271 cv( node ),
1272 get<Expression>().accept1( node->expr ),
1273 (bool)node->kind
1274 };
1275 return nullptr;
1276 }
1277
1278 const ast::Type * visit( const ast::VarArgsType * node ) override final {
1279 this->node = new VarArgsType{ cv( node ) };
1280 return nullptr;
1281 }
1282
1283 const ast::Type * visit( const ast::ZeroType * node ) override final {
1284 this->node = new ZeroType{ cv( node ) };
1285 return nullptr;
1286 }
1287
1288 const ast::Type * visit( const ast::OneType * node ) override final {
1289 this->node = new OneType{ cv( node ) };
1290 return nullptr;
1291 }
1292
1293 const ast::Type * visit( const ast::GlobalScopeType * ) override final {
1294 this->node = new GlobalScopeType{};
1295 return nullptr;
1296 }
1297
1298 const ast::Designation * visit( const ast::Designation * node ) override final {
1299 auto designation = new Designation( get<Expression>().acceptL( node->designators ) );
1300 designation->location = node->location;
1301 this->node = designation;
1302 return nullptr;
1303 }
1304
1305 const ast::Init * visit( const ast::SingleInit * node ) override final {
1306 auto init = new SingleInit(
1307 get<Expression>().accept1( node->value ),
1308 ast::MaybeConstruct == node->maybeConstructed
1309 );
1310 init->location = node->location;
1311 this->node = init;
1312 return nullptr;
1313 }
1314
1315 const ast::Init * visit( const ast::ListInit * node ) override final {
1316 auto init = new ListInit(
1317 get<Initializer>().acceptL( node->initializers ),
1318 get<Designation>().acceptL( node->designations ),
1319 ast::MaybeConstruct == node->maybeConstructed
1320 );
1321 init->location = node->location;
1322 this->node = init;
1323 return nullptr;
1324 }
1325
1326 const ast::Init * visit( const ast::ConstructorInit * node ) override final {
1327 auto init = new ConstructorInit(
1328 get<Statement>().accept1( node->ctor ),
1329 get<Statement>().accept1( node->dtor ),
1330 get<Initializer>().accept1( node->init )
1331 );
1332 init->location = node->location;
1333 this->node = init;
1334 return nullptr;
1335 }
1336
1337 const ast::Attribute * visit( const ast::Attribute * node ) override final {
1338 auto attr = new Attribute(
1339 node->name,
1340 get<Expression>().acceptL(node->params)
1341 );
1342 this->node = attr;
1343 return nullptr;
1344 }
1345
1346 const ast::TypeSubstitution * visit( const ast::TypeSubstitution * node ) override final {
1347 // Handled by convertTypeSubstitution helper instead.
1348 // TypeSubstitution is not a node in the old model, so the conversion result wouldn't fit in this->node.
1349 assert( 0 );
1350 (void)node;
1351 return nullptr;
1352 }
1353};
1354
1355std::list< Declaration * > convert( const std::list< ast::ptr< ast::Decl > > && translationUnit ) {
1356 ConverterNewToOld c;
1357 std::list< Declaration * > decls;
1358 for(auto d : translationUnit) {
1359 decls.emplace_back( c.decl( d ) );
1360 }
1361 return decls;
1362}
1363
1364//================================================================================================
1365
1366class ConverterOldToNew : public Visitor {
1367public:
1368 ast::Decl * decl() {
1369 return strict_dynamic_cast< ast::Decl * >( node );
1370 }
1371
1372 ConverterOldToNew() = default;
1373 ConverterOldToNew(const ConverterOldToNew &) = delete;
1374 ConverterOldToNew(ConverterOldToNew &&) = delete;
1375private:
1376 /// conversion output
1377 ast::Node * node = nullptr;
1378 /// cache of nodes that might be referenced by readonly<> for de-duplication
1379 std::unordered_map< BaseSyntaxNode *, ast::Node * > cache = {};
1380
1381 // Local Utilities:
1382
1383 #define construct(T, key, ...) ({ \
1384 void * data = ::operator new(sizeof(T)); \
1385 cache.emplace( key, (T*)data ); \
1386 new (data) T( __VA_ARGS__ ); \
1387 })
1388
1389 template<typename NewT, typename OldT>
1390 NewT * getAccept1( OldT old ) {
1391 if ( ! old ) return nullptr;
1392 old->accept(*this);
1393 ast::Node * ret = node;
1394 node = nullptr;
1395 return strict_dynamic_cast< NewT * >( ret );
1396 }
1397
1398# define GET_ACCEPT_1(child, type) \
1399 getAccept1< ast::type, decltype( old->child ) >( old->child )
1400
1401 template<typename NewT, typename OldC>
1402 std::vector< ast::ptr<NewT> > getAcceptV( OldC& old ) {
1403 std::vector< ast::ptr<NewT> > ret;
1404 ret.reserve( old.size() );
1405 for ( auto a : old ) {
1406 a->accept( *this );
1407 ret.emplace_back( strict_dynamic_cast< NewT * >(node) );
1408 node = nullptr;
1409 }
1410 return ret;
1411 }
1412
1413# define GET_ACCEPT_V(child, type) \
1414 getAcceptV< ast::type, decltype( old->child ) >( old->child )
1415
1416 ast::Label make_label(Label* old) {
1417 return ast::Label(
1418 old->labelled->location,
1419 old->name,
1420 GET_ACCEPT_V(attributes, Attribute)
1421 );
1422 }
1423
1424 template<template <class...> class C>
1425 C<ast::Label> make_labels(C<Label> olds) {
1426 C<ast::Label> ret;
1427 for (auto oldn : olds) {
1428 ret.push_back( make_label( &oldn ) );
1429 }
1430 return ret;
1431 }
1432
1433# define GET_LABELS_V(labels) \
1434 to<std::vector>::from( make_labels( std::move( labels ) ) )
1435
1436 static ast::CV::Qualifiers cv( Type * ty ) { return { ty->get_qualifiers().val }; }
1437
1438 /// returns true and sets `node` if in cache
1439 bool inCache( BaseSyntaxNode * old ) {
1440 auto it = cache.find( old );
1441 if ( it == cache.end() ) return false;
1442 node = it->second;
1443 return true;
1444 }
1445
1446 // Now all the visit functions:
1447
1448 virtual void visit( ObjectDecl * old ) override final {
1449 if( old->name == "tmp" ) {
1450 std::cerr << "building parameters for" << (void*)old << std::endl;
1451 }
1452 auto&& type = GET_ACCEPT_1(type, Type);
1453 auto&& init = GET_ACCEPT_1(init, Init);
1454 auto&& bfwd = GET_ACCEPT_1(bitfieldWidth, Expr);
1455 auto&& attr = GET_ACCEPT_V(attributes, Attribute);
1456 if( old->name == "tmp" ) {
1457 std::cerr << "checking cache for " << (void*)old << std::endl;
1458 }
1459 if ( inCache( old ) ) {
1460 if( old->name == "tmp" ) {
1461 std::cerr << (void*)old << "(old) in cache " << (void*)this->node << "(new)" << std::endl;
1462 }
1463 return;
1464 }
1465 auto decl = new ast::ObjectDecl(
1466 old->location,
1467 old->name,
1468 type,
1469 init,
1470 { old->get_storageClasses().val },
1471 { old->linkage.val },
1472 bfwd,
1473 std::move(attr),
1474 { old->get_funcSpec().val }
1475 );
1476 cache.emplace(old, decl);
1477 if( old->name == "tmp" ) {
1478 std::cerr << (void*)old << "(old) added to cache with " << (void*)decl << "(new)" << std::endl;
1479 }
1480 assert(cache.find( old ) != cache.end());
1481 decl->scopeLevel = old->scopeLevel;
1482 decl->mangleName = old->mangleName;
1483 decl->isDeleted = old->isDeleted;
1484 decl->uniqueId = old->uniqueId;
1485 decl->extension = old->extension;
1486
1487 this->node = decl;
1488
1489 if( old->name == "tmp" ) {
1490 std::cerr << (void*)old << "(old) created " << (void*)this->node << "(new)" << std::endl;
1491 }
1492 }
1493
1494 virtual void visit( FunctionDecl * old ) override final {
1495 if ( inCache( old ) ) return;
1496 auto decl = new ast::FunctionDecl{
1497 old->location,
1498 old->name,
1499 GET_ACCEPT_1(type, FunctionType),
1500 {},
1501 { old->storageClasses.val },
1502 { old->linkage.val },
1503 GET_ACCEPT_V(attributes, Attribute),
1504 { old->get_funcSpec().val }
1505 };
1506 cache.emplace( old, decl );
1507 decl->withExprs = GET_ACCEPT_V(withExprs, Expr);
1508 decl->stmts = GET_ACCEPT_1(statements, CompoundStmt);
1509 decl->scopeLevel = old->scopeLevel;
1510 decl->mangleName = old->mangleName;
1511 decl->isDeleted = old->isDeleted;
1512 decl->uniqueId = old->uniqueId;
1513 decl->extension = old->extension;
1514
1515 this->node = decl;
1516
1517 if ( Validate::dereferenceOperator == old ) {
1518 dereferenceOperator = decl;
1519 }
1520
1521 if ( Validate::dtorStructDestroy == old ) {
1522 dtorStructDestroy = decl;
1523 }
1524 }
1525
1526 virtual void visit( StructDecl * old ) override final {
1527 if ( inCache( old ) ) return;
1528 auto decl = new ast::StructDecl(
1529 old->location,
1530 old->name,
1531 old->kind,
1532 GET_ACCEPT_V(attributes, Attribute),
1533 { old->linkage.val }
1534 );
1535 cache.emplace( old, decl );
1536 decl->parent = GET_ACCEPT_1(parent, AggregateDecl);
1537 decl->body = old->body;
1538 decl->params = GET_ACCEPT_V(parameters, TypeDecl);
1539 decl->members = GET_ACCEPT_V(members, Decl);
1540 decl->extension = old->extension;
1541 decl->uniqueId = old->uniqueId;
1542 decl->storage = { old->storageClasses.val };
1543
1544 this->node = decl;
1545
1546 if ( Validate::dtorStruct == old ) {
1547 dtorStruct = decl;
1548 }
1549 }
1550
1551 virtual void visit( UnionDecl * old ) override final {
1552 if ( inCache( old ) ) return;
1553 auto decl = new ast::UnionDecl(
1554 old->location,
1555 old->name,
1556 GET_ACCEPT_V(attributes, Attribute),
1557 { old->linkage.val }
1558 );
1559 cache.emplace( old, decl );
1560 decl->parent = GET_ACCEPT_1(parent, AggregateDecl);
1561 decl->body = old->body;
1562 decl->params = GET_ACCEPT_V(parameters, TypeDecl);
1563 decl->members = GET_ACCEPT_V(members, Decl);
1564 decl->extension = old->extension;
1565 decl->uniqueId = old->uniqueId;
1566 decl->storage = { old->storageClasses.val };
1567
1568 this->node = decl;
1569 }
1570
1571 virtual void visit( EnumDecl * old ) override final {
1572 if ( inCache( old ) ) return;
1573 auto decl = new ast::EnumDecl(
1574 old->location,
1575 old->name,
1576 GET_ACCEPT_V(attributes, Attribute),
1577 { old->linkage.val }
1578 );
1579 cache.emplace( old, decl );
1580 decl->parent = GET_ACCEPT_1(parent, AggregateDecl);
1581 decl->body = old->body;
1582 decl->params = GET_ACCEPT_V(parameters, TypeDecl);
1583 decl->members = GET_ACCEPT_V(members, Decl);
1584 decl->extension = old->extension;
1585 decl->uniqueId = old->uniqueId;
1586 decl->storage = { old->storageClasses.val };
1587
1588 this->node = decl;
1589 }
1590
1591 virtual void visit( TraitDecl * old ) override final {
1592 if ( inCache( old ) ) return;
1593 auto decl = new ast::TraitDecl(
1594 old->location,
1595 old->name,
1596 GET_ACCEPT_V(attributes, Attribute),
1597 { old->linkage.val }
1598 );
1599 cache.emplace( old, decl );
1600 decl->parent = GET_ACCEPT_1(parent, AggregateDecl);
1601 decl->body = old->body;
1602 decl->params = GET_ACCEPT_V(parameters, TypeDecl);
1603 decl->members = GET_ACCEPT_V(members, Decl);
1604 decl->extension = old->extension;
1605 decl->uniqueId = old->uniqueId;
1606 decl->storage = { old->storageClasses.val };
1607
1608 this->node = decl;
1609 }
1610
1611 virtual void visit( TypeDecl * old ) override final {
1612 if ( inCache( old ) ) return;
1613 auto decl = new ast::TypeDecl{
1614 old->location,
1615 old->name,
1616 { old->storageClasses.val },
1617 GET_ACCEPT_1(base, Type),
1618 (ast::TypeVar::Kind)(unsigned)old->kind,
1619 old->sized,
1620 GET_ACCEPT_1(init, Type)
1621 };
1622 cache.emplace( old, decl );
1623 decl->assertions = GET_ACCEPT_V(assertions, DeclWithType);
1624 decl->params = GET_ACCEPT_V(parameters, TypeDecl);
1625 decl->extension = old->extension;
1626 decl->uniqueId = old->uniqueId;
1627
1628 this->node = decl;
1629 }
1630
1631 virtual void visit( TypedefDecl * old ) override final {
1632 auto decl = new ast::TypedefDecl(
1633 old->location,
1634 old->name,
1635 { old->storageClasses.val },
1636 GET_ACCEPT_1(base, Type),
1637 { old->linkage.val }
1638 );
1639 decl->assertions = GET_ACCEPT_V(assertions, DeclWithType);
1640 decl->params = GET_ACCEPT_V(parameters, TypeDecl);
1641 decl->extension = old->extension;
1642 decl->uniqueId = old->uniqueId;
1643 decl->storage = { old->storageClasses.val };
1644
1645 this->node = decl;
1646 }
1647
1648 virtual void visit( AsmDecl * old ) override final {
1649 auto decl = new ast::AsmDecl{
1650 old->location,
1651 GET_ACCEPT_1(stmt, AsmStmt)
1652 };
1653 decl->extension = old->extension;
1654 decl->uniqueId = old->uniqueId;
1655 decl->storage = { old->storageClasses.val };
1656
1657 this->node = decl;
1658 }
1659
1660 virtual void visit( StaticAssertDecl * old ) override final {
1661 auto decl = new ast::StaticAssertDecl{
1662 old->location,
1663 GET_ACCEPT_1(condition, Expr),
1664 GET_ACCEPT_1(message, ConstantExpr)
1665 };
1666 decl->extension = old->extension;
1667 decl->uniqueId = old->uniqueId;
1668 decl->storage = { old->storageClasses.val };
1669
1670 this->node = decl;
1671 }
1672
1673 virtual void visit( CompoundStmt * old ) override final {
1674 if ( inCache( old ) ) return;
1675 auto stmt = new ast::CompoundStmt(
1676 old->location,
1677 to<std::list>::from( GET_ACCEPT_V(kids, Stmt) ),
1678 GET_LABELS_V(old->labels)
1679 );
1680
1681 this->node = stmt;
1682 cache.emplace( old, this->node );
1683 }
1684
1685 virtual void visit( ExprStmt * old ) override final {
1686 if ( inCache( old ) ) return;
1687 this->node = new ast::ExprStmt(
1688 old->location,
1689 GET_ACCEPT_1(expr, Expr),
1690 GET_LABELS_V(old->labels)
1691 );
1692 cache.emplace( old, this->node );
1693 }
1694
1695 virtual void visit( AsmStmt * old ) override final {
1696 if ( inCache( old ) ) return;
1697 this->node = new ast::AsmStmt(
1698 old->location,
1699 old->voltile,
1700 GET_ACCEPT_1(instruction, Expr),
1701 GET_ACCEPT_V(output, Expr),
1702 GET_ACCEPT_V(input, Expr),
1703 GET_ACCEPT_V(clobber, ConstantExpr),
1704 GET_LABELS_V(old->gotolabels),
1705 GET_LABELS_V(old->labels)
1706 );
1707 cache.emplace( old, this->node );
1708 }
1709
1710 virtual void visit( DirectiveStmt * old ) override final {
1711 if ( inCache( old ) ) return;
1712 this->node = new ast::DirectiveStmt(
1713 old->location,
1714 old->directive,
1715 GET_LABELS_V(old->labels)
1716 );
1717 cache.emplace( old, this->node );
1718 }
1719
1720 virtual void visit( IfStmt * old ) override final {
1721 if ( inCache( old ) ) return;
1722 this->node = new ast::IfStmt(
1723 old->location,
1724 GET_ACCEPT_1(condition, Expr),
1725 GET_ACCEPT_1(thenPart, Stmt),
1726 GET_ACCEPT_1(elsePart, Stmt),
1727 GET_ACCEPT_V(initialization, Stmt),
1728 GET_LABELS_V(old->labels)
1729 );
1730 cache.emplace( old, this->node );
1731 }
1732
1733 virtual void visit( SwitchStmt * old ) override final {
1734 if ( inCache( old ) ) return;
1735 this->node = new ast::SwitchStmt(
1736 old->location,
1737 GET_ACCEPT_1(condition, Expr),
1738 GET_ACCEPT_V(statements, Stmt),
1739 GET_LABELS_V(old->labels)
1740 );
1741 cache.emplace( old, this->node );
1742 }
1743
1744 virtual void visit( CaseStmt * old ) override final {
1745 if ( inCache( old ) ) return;
1746 this->node = new ast::CaseStmt(
1747 old->location,
1748 GET_ACCEPT_1(condition, Expr),
1749 GET_ACCEPT_V(stmts, Stmt),
1750 GET_LABELS_V(old->labels)
1751 );
1752 cache.emplace( old, this->node );
1753 }
1754
1755 virtual void visit( WhileStmt * old ) override final {
1756 if ( inCache( old ) ) return;
1757 this->node = new ast::WhileStmt(
1758 old->location,
1759 GET_ACCEPT_1(condition, Expr),
1760 GET_ACCEPT_1(body, Stmt),
1761 GET_ACCEPT_V(initialization, Stmt),
1762 old->isDoWhile,
1763 GET_LABELS_V(old->labels)
1764 );
1765 cache.emplace( old, this->node );
1766 }
1767
1768 virtual void visit( ForStmt * old ) override final {
1769 if ( inCache( old ) ) return;
1770 this->node = new ast::ForStmt(
1771 old->location,
1772 GET_ACCEPT_V(initialization, Stmt),
1773 GET_ACCEPT_1(condition, Expr),
1774 GET_ACCEPT_1(increment, Expr),
1775 GET_ACCEPT_1(body, Stmt),
1776 GET_LABELS_V(old->labels)
1777 );
1778 cache.emplace( old, this->node );
1779 }
1780
1781 virtual void visit( BranchStmt * old ) override final {
1782 if ( inCache( old ) ) return;
1783 if (old->computedTarget) {
1784 this->node = new ast::BranchStmt(
1785 old->location,
1786 GET_ACCEPT_1(computedTarget, Expr),
1787 GET_LABELS_V(old->labels)
1788 );
1789 } else {
1790 ast::BranchStmt::Kind kind;
1791 switch (old->type) {
1792 #define CASE(n) \
1793 case BranchStmt::n: \
1794 kind = ast::BranchStmt::n; \
1795 break
1796 CASE(Goto);
1797 CASE(Break);
1798 CASE(Continue);
1799 CASE(FallThrough);
1800 CASE(FallThroughDefault);
1801 #undef CASE
1802 default:
1803 assertf(false, "Invalid BranchStmt::Type %d\n", old->type);
1804 }
1805
1806 Label label = old->originalTarget;
1807 auto stmt = new ast::BranchStmt(
1808 old->location,
1809 kind,
1810 make_label(&label),
1811 GET_LABELS_V(old->labels)
1812 );
1813 stmt->target = make_label(&old->target);
1814 this->node = stmt;
1815 }
1816 cache.emplace( old, this->node );
1817 }
1818
1819 virtual void visit( ReturnStmt * old ) override final {
1820 if ( inCache( old ) ) return;
1821 this->node = new ast::ReturnStmt(
1822 old->location,
1823 GET_ACCEPT_1(expr, Expr),
1824 GET_LABELS_V(old->labels)
1825 );
1826 cache.emplace( old, this->node );
1827 }
1828
1829 virtual void visit( ThrowStmt * old ) override final {
1830 if ( inCache( old ) ) return;
1831 ast::ExceptionKind kind;
1832 switch (old->kind) {
1833 case ThrowStmt::Terminate:
1834 kind = ast::ExceptionKind::Terminate;
1835 break;
1836 case ThrowStmt::Resume:
1837 kind = ast::ExceptionKind::Resume;
1838 break;
1839 default:
1840 assertf(false, "Invalid ThrowStmt::Kind %d\n", old->kind);
1841 }
1842
1843 this->node = new ast::ThrowStmt(
1844 old->location,
1845 kind,
1846 GET_ACCEPT_1(expr, Expr),
1847 GET_ACCEPT_1(target, Expr),
1848 GET_LABELS_V(old->labels)
1849 );
1850 cache.emplace( old, this->node );
1851 }
1852
1853 virtual void visit( TryStmt * old ) override final {
1854 if ( inCache( old ) ) return;
1855 this->node = new ast::TryStmt(
1856 old->location,
1857 GET_ACCEPT_1(block, CompoundStmt),
1858 GET_ACCEPT_V(handlers, CatchStmt),
1859 GET_ACCEPT_1(finallyBlock, FinallyStmt),
1860 GET_LABELS_V(old->labels)
1861 );
1862 cache.emplace( old, this->node );
1863 }
1864
1865 virtual void visit( CatchStmt * old ) override final {
1866 if ( inCache( old ) ) return;
1867 ast::ExceptionKind kind;
1868 switch (old->kind) {
1869 case CatchStmt::Terminate:
1870 kind = ast::ExceptionKind::Terminate;
1871 break;
1872 case CatchStmt::Resume:
1873 kind = ast::ExceptionKind::Resume;
1874 break;
1875 default:
1876 assertf(false, "Invalid CatchStmt::Kind %d\n", old->kind);
1877 }
1878
1879 this->node = new ast::CatchStmt(
1880 old->location,
1881 kind,
1882 GET_ACCEPT_1(decl, Decl),
1883 GET_ACCEPT_1(cond, Expr),
1884 GET_ACCEPT_1(body, Stmt),
1885 GET_LABELS_V(old->labels)
1886 );
1887 cache.emplace( old, this->node );
1888 }
1889
1890 virtual void visit( FinallyStmt * old ) override final {
1891 if ( inCache( old ) ) return;
1892 this->node = new ast::FinallyStmt(
1893 old->location,
1894 GET_ACCEPT_1(block, CompoundStmt),
1895 GET_LABELS_V(old->labels)
1896 );
1897 cache.emplace( old, this->node );
1898 }
1899
1900 virtual void visit( WaitForStmt * old ) override final {
1901 if ( inCache( old ) ) return;
1902 ast::WaitForStmt * stmt = new ast::WaitForStmt(
1903 old->location,
1904 GET_LABELS_V(old->labels)
1905 );
1906
1907 stmt->clauses.reserve( old->clauses.size() );
1908 for (size_t i = 0 ; i < old->clauses.size() ; ++i) {
1909 stmt->clauses.push_back({
1910 ast::WaitForStmt::Target{
1911 GET_ACCEPT_1(clauses[i].target.function, Expr),
1912 GET_ACCEPT_V(clauses[i].target.arguments, Expr)
1913 },
1914 GET_ACCEPT_1(clauses[i].statement, Stmt),
1915 GET_ACCEPT_1(clauses[i].condition, Expr)
1916 });
1917 }
1918 stmt->timeout = {
1919 GET_ACCEPT_1(timeout.time, Expr),
1920 GET_ACCEPT_1(timeout.statement, Stmt),
1921 GET_ACCEPT_1(timeout.condition, Expr),
1922 };
1923 stmt->orElse = {
1924 GET_ACCEPT_1(timeout.statement, Stmt),
1925 GET_ACCEPT_1(timeout.condition, Expr),
1926 };
1927
1928 this->node = stmt;
1929 cache.emplace( old, this->node );
1930 }
1931
1932 virtual void visit( WithStmt * old ) override final {
1933 if ( inCache( old ) ) return;
1934 this->node = new ast::WithStmt(
1935 old->location,
1936 GET_ACCEPT_V(exprs, Expr),
1937 GET_ACCEPT_1(stmt, Stmt),
1938 GET_LABELS_V(old->labels)
1939 );
1940 cache.emplace( old, this->node );
1941 }
1942
1943 virtual void visit( NullStmt * old ) override final {
1944 if ( inCache( old ) ) return;
1945 this->node = new ast::NullStmt(
1946 old->location,
1947 GET_LABELS_V(old->labels)
1948 );
1949 cache.emplace( old, this->node );
1950 }
1951
1952 virtual void visit( DeclStmt * old ) override final {
1953 if ( inCache( old ) ) return;
1954 this->node = new ast::DeclStmt(
1955 old->location,
1956 GET_ACCEPT_1(decl, Decl),
1957 GET_LABELS_V(old->labels)
1958 );
1959 cache.emplace( old, this->node );
1960 }
1961
1962 virtual void visit( ImplicitCtorDtorStmt * old ) override final {
1963 if ( inCache( old ) ) return;
1964 auto stmt = new ast::ImplicitCtorDtorStmt(
1965 old->location,
1966 nullptr,
1967 GET_LABELS_V(old->labels)
1968 );
1969 cache.emplace( old, stmt );
1970 stmt->callStmt = GET_ACCEPT_1(callStmt, Stmt);
1971 this->node = stmt;
1972 }
1973
1974 ast::TypeSubstitution * convertTypeSubstitution(const TypeSubstitution * old) {
1975
1976 if (!old) return nullptr;
1977
1978 ast::TypeSubstitution *rslt = new ast::TypeSubstitution();
1979
1980 for (decltype(old->begin()) old_i = old->begin(); old_i != old->end(); old_i++) {
1981 rslt->add( old_i->first,
1982 getAccept1<ast::Type>(old_i->second) );
1983 }
1984
1985 for (decltype(old->beginVar()) old_i = old->beginVar(); old_i != old->endVar(); old_i++) {
1986 rslt->addVar( old_i->first,
1987 getAccept1<ast::Expr>(old_i->second) );
1988 }
1989
1990 return rslt;
1991 }
1992
1993 void convertInferUnion(ast::Expr::InferUnion &newInferred,
1994 const std::map<UniqueId,ParamEntry> &oldInferParams,
1995 const std::vector<UniqueId> &oldResnSlots) {
1996
1997 assert( oldInferParams.empty() || oldResnSlots.empty() );
1998 assert( newInferred.mode == ast::Expr::InferUnion::Empty );
1999
2000 if ( !oldInferParams.empty() ) {
2001 ast::InferredParams &tgt = newInferred.inferParams();
2002 for (auto old : oldInferParams) {
2003 tgt[old.first] = ast::ParamEntry(
2004 old.second.decl,
2005 getAccept1<ast::Type>(old.second.actualType),
2006 getAccept1<ast::Type>(old.second.formalType),
2007 getAccept1<ast::Expr>(old.second.expr)
2008 );
2009 }
2010 } else if ( !oldResnSlots.empty() ) {
2011 ast::ResnSlots &tgt = newInferred.resnSlots();
2012 for (auto old : oldResnSlots) {
2013 tgt.push_back(old);
2014 }
2015 }
2016 }
2017
2018 ast::Expr * visitBaseExpr_SkipResultType(Expression * old, ast::Expr * nw) {
2019
2020 nw->env = convertTypeSubstitution(old->env);
2021
2022 nw->extension = old->extension;
2023 convertInferUnion(nw->inferred, old->inferParams, old->resnSlots);
2024
2025 return nw;
2026 }
2027
2028 ast::Expr * visitBaseExpr(Expression * old, ast::Expr * nw) {
2029
2030 nw->result = GET_ACCEPT_1(result, Type);
2031 return visitBaseExpr_SkipResultType(old, nw);;
2032 }
2033
2034 virtual void visit( ApplicationExpr * old ) override final {
2035 this->node = visitBaseExpr( old,
2036 new ast::ApplicationExpr(
2037 old->location,
2038 GET_ACCEPT_1(function, Expr),
2039 GET_ACCEPT_V(args, Expr)
2040 )
2041 );
2042 }
2043
2044 virtual void visit( UntypedExpr * old ) override final {
2045 this->node = visitBaseExpr( old,
2046 new ast::UntypedExpr(
2047 old->location,
2048 GET_ACCEPT_1(function, Expr),
2049 GET_ACCEPT_V(args, Expr)
2050 )
2051 );
2052 }
2053
2054 virtual void visit( NameExpr * old ) override final {
2055 this->node = visitBaseExpr( old,
2056 new ast::NameExpr(
2057 old->location,
2058 old->get_name()
2059 )
2060 );
2061 }
2062
2063 virtual void visit( CastExpr * old ) override final {
2064 this->node = visitBaseExpr( old,
2065 new ast::CastExpr(
2066 old->location,
2067 GET_ACCEPT_1(arg, Expr),
2068 old->isGenerated ? ast::GeneratedCast : ast::ExplicitCast
2069 )
2070 );
2071 }
2072
2073 virtual void visit( KeywordCastExpr * old) override final {
2074 ast::KeywordCastExpr::Target castTarget = ast::KeywordCastExpr::NUMBER_OF_TARGETS;
2075 switch (old->target) {
2076 case KeywordCastExpr::Coroutine:
2077 castTarget = ast::KeywordCastExpr::Coroutine;
2078 break;
2079 case KeywordCastExpr::Thread:
2080 castTarget = ast::KeywordCastExpr::Thread;
2081 break;
2082 case KeywordCastExpr::Monitor:
2083 castTarget = ast::KeywordCastExpr::Monitor;
2084 break;
2085 default:
2086 break;
2087 }
2088 assert ( castTarget < ast::KeywordCastExpr::NUMBER_OF_TARGETS );
2089 this->node = visitBaseExpr( old,
2090 new ast::KeywordCastExpr(
2091 old->location,
2092 GET_ACCEPT_1(arg, Expr),
2093 castTarget
2094 )
2095 );
2096 }
2097
2098 virtual void visit( VirtualCastExpr * old ) override final {
2099 this->node = visitBaseExpr_SkipResultType( old,
2100 new ast::VirtualCastExpr(
2101 old->location,
2102 GET_ACCEPT_1(arg, Expr),
2103 GET_ACCEPT_1(result, Type)
2104 )
2105 );
2106 }
2107
2108 virtual void visit( AddressExpr * old ) override final {
2109 this->node = visitBaseExpr( old,
2110 new ast::AddressExpr(
2111 old->location,
2112 GET_ACCEPT_1(arg, Expr)
2113 )
2114 );
2115 }
2116
2117 virtual void visit( LabelAddressExpr * old ) override final {
2118 this->node = visitBaseExpr( old,
2119 new ast::LabelAddressExpr(
2120 old->location,
2121 make_label(&old->arg)
2122 )
2123 );
2124 }
2125
2126 virtual void visit( UntypedMemberExpr * old ) override final {
2127 this->node = visitBaseExpr( old,
2128 new ast::UntypedMemberExpr(
2129 old->location,
2130 GET_ACCEPT_1(member, Expr),
2131 GET_ACCEPT_1(aggregate, Expr)
2132 )
2133 );
2134 }
2135
2136 virtual void visit( MemberExpr * old ) override final {
2137 this->node = visitBaseExpr( old,
2138 new ast::MemberExpr(
2139 old->location,
2140 GET_ACCEPT_1(member, DeclWithType),
2141 GET_ACCEPT_1(aggregate, Expr)
2142 )
2143 );
2144 }
2145
2146 virtual void visit( VariableExpr * old ) override final {
2147 auto expr = new ast::VariableExpr(
2148 old->location
2149 );
2150
2151 visitBaseExpr( old,
2152 expr
2153 );
2154
2155 expr->var = GET_ACCEPT_1(var, DeclWithType);
2156 expr->result = expr->var->get_type();
2157 add_qualifiers( expr->result, ast::CV::Lvalue );
2158 this->node = expr;
2159 }
2160
2161 bool isIntlikeConstantType(const Type *t) {
2162 if ( const BasicType * basicType = dynamic_cast< const BasicType * >( t ) ) {
2163 if ( basicType->isInteger() ) {
2164 return true;
2165 }
2166 } else if ( dynamic_cast< const OneType * >( t ) ) {
2167 return true;
2168 } else if ( dynamic_cast< const ZeroType * >( t ) ) {
2169 return true;
2170 } else if ( dynamic_cast< const PointerType * >( t ) ) {
2171 // null pointer constants, with zero int-values
2172 return true;
2173 }
2174 return false;
2175 }
2176
2177 int isFloatlikeConstantType(const Type *t) {
2178 if ( const BasicType * bty = dynamic_cast< const BasicType * >( t ) ) {
2179 if ( ! bty->isInteger() ) {
2180 return true;
2181 }
2182 }
2183 return false;
2184 }
2185
2186 int isStringlikeConstantType(const Type *t) {
2187 if ( const ArrayType * aty = dynamic_cast< const ArrayType * >( t ) ) {
2188 if ( const BasicType * bty = dynamic_cast< const BasicType * >( aty->base ) ) {
2189 if ( bty->kind == BasicType::Kind::Char ) {
2190 return true;
2191 }
2192 }
2193 }
2194 return false;
2195 }
2196
2197 virtual void visit( ConstantExpr * old ) override final {
2198 ast::ConstantExpr *rslt = nullptr;
2199 if (isIntlikeConstantType(old->result)) {
2200 rslt = new ast::ConstantExpr(
2201 old->location,
2202 GET_ACCEPT_1(result, Type),
2203 old->constant.get_value(),
2204 (unsigned long long) old->intValue(),
2205 ast::ConstantExpr::Kind::Integer
2206 );
2207 } else if (isFloatlikeConstantType(old->result)) {
2208 rslt = new ast::ConstantExpr(
2209 old->location,
2210 GET_ACCEPT_1(result, Type),
2211 old->constant.get_value(),
2212 (double) old->constant.get_dval()
2213 );
2214 } else if (isStringlikeConstantType(old->result)) {
2215 rslt = new ast::ConstantExpr(
2216 old->location,
2217 GET_ACCEPT_1(result, Type),
2218 old->constant.get_value(),
2219 0,
2220 ast::ConstantExpr::Kind::String
2221 );
2222 }
2223 assert(rslt);
2224 this->node = visitBaseExpr( old, rslt );
2225 }
2226
2227 virtual void visit( SizeofExpr * old ) override final {
2228 assert (old->expr || old->type);
2229 assert (! (old->expr && old->type));
2230 ast::SizeofExpr *rslt;
2231 if (old->expr) {
2232 assert(!old->isType);
2233 rslt = new ast::SizeofExpr(
2234 old->location,
2235 GET_ACCEPT_1(expr, Expr)
2236 );
2237 }
2238 if (old->type) {
2239 assert(old->isType);
2240 rslt = new ast::SizeofExpr(
2241 old->location,
2242 GET_ACCEPT_1(type, Type)
2243 );
2244 }
2245 this->node = visitBaseExpr( old, rslt );
2246 }
2247
2248 virtual void visit( AlignofExpr * old ) override final {
2249 assert (old->expr || old->type);
2250 assert (! (old->expr && old->type));
2251 ast::AlignofExpr *rslt;
2252 if (old->expr) {
2253 assert(!old->isType);
2254 rslt = new ast::AlignofExpr(
2255 old->location,
2256 GET_ACCEPT_1(expr, Expr)
2257 );
2258 }
2259 if (old->type) {
2260 assert(old->isType);
2261 rslt = new ast::AlignofExpr(
2262 old->location,
2263 GET_ACCEPT_1(type, Type)
2264 );
2265 }
2266 this->node = visitBaseExpr( old, rslt );
2267 }
2268
2269 virtual void visit( UntypedOffsetofExpr * old ) override final {
2270 this->node = visitBaseExpr( old,
2271 new ast::UntypedOffsetofExpr(
2272 old->location,
2273 GET_ACCEPT_1(type, Type),
2274 old->member
2275 )
2276 );
2277 }
2278
2279 virtual void visit( OffsetofExpr * old ) override final {
2280 this->node = visitBaseExpr( old,
2281 new ast::OffsetofExpr(
2282 old->location,
2283 GET_ACCEPT_1(type, Type),
2284 GET_ACCEPT_1(member, DeclWithType)
2285 )
2286 );
2287 }
2288
2289 virtual void visit( OffsetPackExpr * old ) override final {
2290 this->node = visitBaseExpr( old,
2291 new ast::OffsetPackExpr(
2292 old->location,
2293 GET_ACCEPT_1(type, StructInstType)
2294 )
2295 );
2296 }
2297
2298 virtual void visit( LogicalExpr * old ) override final {
2299 this->node = visitBaseExpr( old,
2300 new ast::LogicalExpr(
2301 old->location,
2302 GET_ACCEPT_1(arg1, Expr),
2303 GET_ACCEPT_1(arg2, Expr),
2304 old->get_isAnd() ?
2305 ast::LogicalFlag::AndExpr :
2306 ast::LogicalFlag::OrExpr
2307 )
2308 );
2309 }
2310
2311 virtual void visit( ConditionalExpr * old ) override final {
2312 this->node = visitBaseExpr( old,
2313 new ast::ConditionalExpr(
2314 old->location,
2315 GET_ACCEPT_1(arg1, Expr),
2316 GET_ACCEPT_1(arg2, Expr),
2317 GET_ACCEPT_1(arg3, Expr)
2318 )
2319 );
2320 }
2321
2322 virtual void visit( CommaExpr * old ) override final {
2323 this->node = visitBaseExpr( old,
2324 new ast::CommaExpr(
2325 old->location,
2326 GET_ACCEPT_1(arg1, Expr),
2327 GET_ACCEPT_1(arg2, Expr)
2328 )
2329 );
2330 }
2331
2332 virtual void visit( TypeExpr * old ) override final {
2333 this->node = visitBaseExpr( old,
2334 new ast::TypeExpr(
2335 old->location,
2336 GET_ACCEPT_1(type, Type)
2337 )
2338 );
2339 }
2340
2341 virtual void visit( AsmExpr * old ) override final {
2342 this->node = visitBaseExpr( old,
2343 new ast::AsmExpr(
2344 old->location,
2345 GET_ACCEPT_1(inout, Expr),
2346 GET_ACCEPT_1(constraint, Expr),
2347 GET_ACCEPT_1(operand, Expr)
2348 )
2349 );
2350 }
2351
2352 virtual void visit( ImplicitCopyCtorExpr * old ) override final {
2353 auto rslt = new ast::ImplicitCopyCtorExpr(
2354 old->location,
2355 GET_ACCEPT_1(callExpr, ApplicationExpr)
2356 );
2357
2358 this->node = visitBaseExpr( old, rslt );
2359 }
2360
2361 virtual void visit( ConstructorExpr * old ) override final {
2362 this->node = visitBaseExpr( old,
2363 new ast::ConstructorExpr(
2364 old->location,
2365 GET_ACCEPT_1(callExpr, Expr)
2366 )
2367 );
2368 }
2369
2370 virtual void visit( CompoundLiteralExpr * old ) override final {
2371 this->node = visitBaseExpr_SkipResultType( old,
2372 new ast::CompoundLiteralExpr(
2373 old->location,
2374 GET_ACCEPT_1(result, Type),
2375 GET_ACCEPT_1(initializer, Init)
2376 )
2377 );
2378 }
2379
2380 virtual void visit( RangeExpr * old ) override final {
2381 this->node = visitBaseExpr( old,
2382 new ast::RangeExpr(
2383 old->location,
2384 GET_ACCEPT_1(low, Expr),
2385 GET_ACCEPT_1(high, Expr)
2386 )
2387 );
2388 }
2389
2390 virtual void visit( UntypedTupleExpr * old ) override final {
2391 this->node = visitBaseExpr( old,
2392 new ast::UntypedTupleExpr(
2393 old->location,
2394 GET_ACCEPT_V(exprs, Expr)
2395 )
2396 );
2397 }
2398
2399 virtual void visit( TupleExpr * old ) override final {
2400 this->node = visitBaseExpr( old,
2401 new ast::TupleExpr(
2402 old->location,
2403 GET_ACCEPT_V(exprs, Expr)
2404 )
2405 );
2406 }
2407
2408 virtual void visit( TupleIndexExpr * old ) override final {
2409 this->node = visitBaseExpr( old,
2410 new ast::TupleIndexExpr(
2411 old->location,
2412 GET_ACCEPT_1(tuple, Expr),
2413 old->index
2414 )
2415 );
2416 }
2417
2418 virtual void visit( TupleAssignExpr * old ) override final {
2419 this->node = visitBaseExpr_SkipResultType( old,
2420 new ast::TupleAssignExpr(
2421 old->location,
2422 GET_ACCEPT_1(result, Type),
2423 GET_ACCEPT_1(stmtExpr, StmtExpr)
2424 )
2425 );
2426 }
2427
2428 virtual void visit( StmtExpr * old ) override final {
2429 auto rslt = new ast::StmtExpr(
2430 old->location,
2431 GET_ACCEPT_1(statements, CompoundStmt)
2432 );
2433 rslt->returnDecls = GET_ACCEPT_V(returnDecls, ObjectDecl);
2434 rslt->dtors = GET_ACCEPT_V(dtors , Expr);
2435
2436 this->node = visitBaseExpr_SkipResultType( old, rslt );
2437 }
2438
2439 virtual void visit( UniqueExpr * old ) override final {
2440 auto rslt = new ast::UniqueExpr(
2441 old->location,
2442 GET_ACCEPT_1(expr, Expr)
2443 );
2444 rslt->object = GET_ACCEPT_1(object, ObjectDecl);
2445 rslt->var = GET_ACCEPT_1(var , VariableExpr);
2446
2447 this->node = visitBaseExpr( old, rslt );
2448 }
2449
2450 virtual void visit( UntypedInitExpr * old ) override final {
2451 std::vector<ast::InitAlternative> initAlts;
2452 for (auto ia : old->initAlts) {
2453 initAlts.push_back(ast::InitAlternative(
2454 getAccept1< ast::Type, Type * >( ia.type ),
2455 getAccept1< ast::Designation, Designation * >( ia.designation )
2456 ));
2457 }
2458 this->node = visitBaseExpr( old,
2459 new ast::UntypedInitExpr(
2460 old->location,
2461 GET_ACCEPT_1(expr, Expr),
2462 std::move(initAlts)
2463 )
2464 );
2465 }
2466
2467 virtual void visit( InitExpr * old ) override final {
2468 this->node = visitBaseExpr( old,
2469 new ast::InitExpr(
2470 old->location,
2471 GET_ACCEPT_1(expr, Expr),
2472 GET_ACCEPT_1(designation, Designation)
2473 )
2474 );
2475 }
2476
2477 virtual void visit( DeletedExpr * old ) override final {
2478 this->node = visitBaseExpr( old,
2479 new ast::DeletedExpr(
2480 old->location,
2481 GET_ACCEPT_1(expr, Expr),
2482 inCache(old->deleteStmt) ?
2483 this->node :
2484 GET_ACCEPT_1(deleteStmt, Node)
2485 )
2486 );
2487 }
2488
2489 virtual void visit( DefaultArgExpr * old ) override final {
2490 this->node = visitBaseExpr( old,
2491 new ast::DefaultArgExpr(
2492 old->location,
2493 GET_ACCEPT_1(expr, Expr)
2494 )
2495 );
2496 }
2497
2498 virtual void visit( GenericExpr * old ) override final {
2499 std::vector<ast::GenericExpr::Association> associations;
2500 for (auto association : old->associations) {
2501 associations.push_back(ast::GenericExpr::Association(
2502 getAccept1< ast::Type, Type * >( association.type ),
2503 getAccept1< ast::Expr, Expression * >( association.expr )
2504 ));
2505 }
2506 this->node = visitBaseExpr( old,
2507 new ast::GenericExpr(
2508 old->location,
2509 GET_ACCEPT_1(control, Expr),
2510 std::move(associations)
2511 )
2512 );
2513 }
2514
2515 virtual void visit( VoidType * old ) override final {
2516 this->node = new ast::VoidType{ cv( old ) };
2517 }
2518
2519 virtual void visit( BasicType * old ) override final {
2520 auto type = new ast::BasicType{ (ast::BasicType::Kind)(unsigned)old->kind, cv( old ) };
2521 // I believe this should always be a BasicType.
2522 if ( Validate::SizeType == old ) {
2523 sizeType = type;
2524 }
2525 this->node = type;
2526 }
2527
2528 virtual void visit( PointerType * old ) override final {
2529 this->node = new ast::PointerType{
2530 GET_ACCEPT_1( base, Type ),
2531 GET_ACCEPT_1( dimension, Expr ),
2532 (ast::LengthFlag)old->isVarLen,
2533 (ast::DimensionFlag)old->isStatic,
2534 cv( old )
2535 };
2536 }
2537
2538 virtual void visit( ArrayType * old ) override final {
2539 this->node = new ast::ArrayType{
2540 GET_ACCEPT_1( base, Type ),
2541 GET_ACCEPT_1( dimension, Expr ),
2542 (ast::LengthFlag)old->isVarLen,
2543 (ast::DimensionFlag)old->isStatic,
2544 cv( old )
2545 };
2546 }
2547
2548 virtual void visit( ReferenceType * old ) override final {
2549 this->node = new ast::ReferenceType{
2550 GET_ACCEPT_1( base, Type ),
2551 cv( old )
2552 };
2553 }
2554
2555 virtual void visit( QualifiedType * old ) override final {
2556 this->node = new ast::QualifiedType{
2557 GET_ACCEPT_1( parent, Type ),
2558 GET_ACCEPT_1( child, Type ),
2559 cv( old )
2560 };
2561 }
2562
2563 virtual void visit( FunctionType * old ) override final {
2564 auto ty = new ast::FunctionType {
2565 (ast::ArgumentFlag)old->isVarArgs,
2566 cv( old )
2567 };
2568 ty->returns = GET_ACCEPT_V( returnVals, DeclWithType );
2569 ty->params = GET_ACCEPT_V( parameters, DeclWithType );
2570 ty->forall = GET_ACCEPT_V( forall, TypeDecl );
2571 this->node = ty;
2572 }
2573
2574 void postvisit( ReferenceToType * old, ast::ReferenceToType * ty ) {
2575 ty->forall = GET_ACCEPT_V( forall, TypeDecl );
2576 ty->params = GET_ACCEPT_V( parameters, Expr );
2577 ty->hoistType = old->hoistType;
2578 }
2579
2580 virtual void visit( StructInstType * old ) override final {
2581 ast::StructInstType * ty;
2582 if ( old->baseStruct ) {
2583 ty = new ast::StructInstType{
2584 GET_ACCEPT_1( baseStruct, StructDecl ),
2585 cv( old ),
2586 GET_ACCEPT_V( attributes, Attribute )
2587 };
2588 } else {
2589 ty = new ast::StructInstType{
2590 old->name,
2591 cv( old ),
2592 GET_ACCEPT_V( attributes, Attribute )
2593 };
2594 }
2595 postvisit( old, ty );
2596 this->node = ty;
2597 }
2598
2599 virtual void visit( UnionInstType * old ) override final {
2600 ast::UnionInstType * ty;
2601 if ( old->baseUnion ) {
2602 ty = new ast::UnionInstType{
2603 GET_ACCEPT_1( baseUnion, UnionDecl ),
2604 cv( old ),
2605 GET_ACCEPT_V( attributes, Attribute )
2606 };
2607 } else {
2608 ty = new ast::UnionInstType{
2609 old->name,
2610 cv( old ),
2611 GET_ACCEPT_V( attributes, Attribute )
2612 };
2613 }
2614 postvisit( old, ty );
2615 this->node = ty;
2616 }
2617
2618 virtual void visit( EnumInstType * old ) override final {
2619 ast::EnumInstType * ty;
2620 if ( old->baseEnum ) {
2621 ty = new ast::EnumInstType{
2622 GET_ACCEPT_1( baseEnum, EnumDecl ),
2623 cv( old ),
2624 GET_ACCEPT_V( attributes, Attribute )
2625 };
2626 } else {
2627 ty = new ast::EnumInstType{
2628 old->name,
2629 cv( old ),
2630 GET_ACCEPT_V( attributes, Attribute )
2631 };
2632 }
2633 postvisit( old, ty );
2634 this->node = ty;
2635 }
2636
2637 virtual void visit( TraitInstType * old ) override final {
2638 ast::TraitInstType * ty;
2639 if ( old->baseTrait ) {
2640 ty = new ast::TraitInstType{
2641 GET_ACCEPT_1( baseTrait, TraitDecl ),
2642 cv( old ),
2643 GET_ACCEPT_V( attributes, Attribute )
2644 };
2645 } else {
2646 ty = new ast::TraitInstType{
2647 old->name,
2648 cv( old ),
2649 GET_ACCEPT_V( attributes, Attribute )
2650 };
2651 }
2652 postvisit( old, ty );
2653 this->node = ty;
2654 }
2655
2656 virtual void visit( TypeInstType * old ) override final {
2657 ast::TypeInstType * ty;
2658 if ( old->baseType ) {
2659 ty = new ast::TypeInstType{
2660 old->name,
2661 GET_ACCEPT_1( baseType, TypeDecl ),
2662 cv( old ),
2663 GET_ACCEPT_V( attributes, Attribute )
2664 };
2665 } else {
2666 ty = new ast::TypeInstType{
2667 old->name,
2668 old->isFtype ? ast::TypeVar::Ftype : ast::TypeVar::Dtype,
2669 cv( old ),
2670 GET_ACCEPT_V( attributes, Attribute )
2671 };
2672 }
2673 postvisit( old, ty );
2674 this->node = ty;
2675 }
2676
2677 virtual void visit( TupleType * old ) override final {
2678 this->node = new ast::TupleType{
2679 GET_ACCEPT_V( types, Type ),
2680 // members generated by TupleType c'tor
2681 cv( old )
2682 };
2683 }
2684
2685 virtual void visit( TypeofType * old ) override final {
2686 this->node = new ast::TypeofType{
2687 GET_ACCEPT_1( expr, Expr ),
2688 (ast::TypeofType::Kind)old->is_basetypeof,
2689 cv( old )
2690 };
2691 }
2692
2693 virtual void visit( AttrType * ) override final {
2694 assertf( false, "AttrType deprecated in new AST." );
2695 }
2696
2697 virtual void visit( VarArgsType * old ) override final {
2698 this->node = new ast::VarArgsType{ cv( old ) };
2699 }
2700
2701 virtual void visit( ZeroType * old ) override final {
2702 this->node = new ast::ZeroType{ cv( old ) };
2703 }
2704
2705 virtual void visit( OneType * old ) override final {
2706 this->node = new ast::OneType{ cv( old ) };
2707 }
2708
2709 virtual void visit( GlobalScopeType * ) override final {
2710 this->node = new ast::GlobalScopeType{};
2711 }
2712
2713 virtual void visit( Designation * old ) override final {
2714 this->node = new ast::Designation(
2715 old->location,
2716 GET_ACCEPT_V(designators, Expr)
2717 );
2718 }
2719
2720 virtual void visit( SingleInit * old ) override final {
2721 this->node = new ast::SingleInit(
2722 old->location,
2723 GET_ACCEPT_1(value, Expr),
2724 (old->get_maybeConstructed()) ? ast::MaybeConstruct : ast::DoConstruct
2725 );
2726 }
2727
2728 virtual void visit( ListInit * old ) override final {
2729 this->node = new ast::ListInit(
2730 old->location,
2731 GET_ACCEPT_V(initializers, Init),
2732 GET_ACCEPT_V(designations, Designation),
2733 (old->get_maybeConstructed()) ? ast::MaybeConstruct : ast::DoConstruct
2734 );
2735 }
2736
2737 virtual void visit( ConstructorInit * old ) override final {
2738 this->node = new ast::ConstructorInit(
2739 old->location,
2740 GET_ACCEPT_1(ctor, Stmt),
2741 GET_ACCEPT_1(dtor, Stmt),
2742 GET_ACCEPT_1(init, Init)
2743 );
2744 }
2745
2746 virtual void visit( Constant * ) override final {
2747 // Handled in visit( ConstantEpxr * ).
2748 // In the new tree, Constant fields are inlined into containing ConstantExpression.
2749 assert( 0 );
2750 }
2751
2752 virtual void visit( Attribute * old ) override final {
2753 this->node = new ast::Attribute(
2754 old->name,
2755 GET_ACCEPT_V( parameters, Expr )
2756 );
2757 }
2758
2759 virtual void visit( AttrExpr * ) override final {
2760 assertf( false, "AttrExpr deprecated in new AST." );
2761 }
2762};
2763
2764#undef GET_LABELS_V
2765#undef GET_ACCEPT_V
2766#undef GET_ACCEPT_1
2767
2768std::list< ast::ptr< ast::Decl > > convert( const std::list< Declaration * > && translationUnit ) {
2769 ConverterOldToNew c;
2770 std::list< ast::ptr< ast::Decl > > decls;
2771 for(auto d : translationUnit) {
2772 d->accept( c );
2773 decls.emplace_back( c.decl() );
2774 }
2775 deleteAll(translationUnit);
2776 return decls;
2777}
Note: See TracBrowser for help on using the repository browser.