source: src/AST/Convert.cpp @ d66e7b7

arm-ehcleanup-dtorsjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-expr
Last change on this file since d66e7b7 was d66e7b7, checked in by Andrew Beach <ajbeach@…>, 3 years ago

Removed ACCEPT_1 and ACCEPT_N from Convert.cpp. Use GET_ACCEPT_? instead.

  • Property mode set to 100644
File size: 16.1 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 --
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 : Fri May 17 11:14:00 2019
13// Update Count     : 2
14//
15
16#include "Convert.hpp"
17
18#include "AST/Pass.hpp"
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
26
27#include "SynTree/Attribute.h"
28#include "SynTree/Declaration.h"
29
30//================================================================================================
31// Utilities
32template<template <class...> class C>
33struct to {
34        template<typename T>
35        static auto from( T && v ) -> C< typename T::value_type > {
36                C< typename T::value_type > l;
37                std::move(std::begin(v), std::end(v), std::back_inserter(l));
38                return l;
39        }
40};
41
42//================================================================================================
43class ConverterNewToOld {
44public:
45        std::list< Declaration * > translationUnit;
46};
47
48std::list< Declaration * > convert( std::list< ast::ptr< ast::Decl > > & translationUnit ) {
49        ast::Pass<ConverterNewToOld> converter;
50        ast::accept_all(translationUnit, converter);
51        return converter.pass.translationUnit;
52}
53
54//================================================================================================
55
56class ConverterOldToNew : public Visitor {
57public:
58        ast::Decl * decl() {
59                return strict_dynamic_cast< ast::Decl * >( node );
60        }
61private:
62        ast::Node * node;
63
64        // Local Utilities:
65
66        template<typename NewT, typename OldT>
67        NewT * getAccept1( OldT old ) {
68                old->accept(*this);
69                return strict_dynamic_cast< NewT * >( node );
70        }
71
72#       define GET_ACCEPT_1(child, type) \
73                getAccept1< ast::type, decltype( old->child ) >( old->child )
74
75        template<typename NewT, typename OldC>
76        std::vector< ast::ptr<NewT> > getAcceptV( OldC& old ) {
77                std::vector< ast::ptr<NewT> > ret;
78                ret.reserve( old.size() );
79                for ( auto a : old ) {
80                        a->accept( *this );
81                        ret.emplace_back( strict_dynamic_cast< NewT * >(node) );
82                }
83                return ret;
84        }
85
86#       define GET_ACCEPT_V(child, type) \
87                getAcceptV< ast::type, decltype( old->child ) >( old->child )
88
89        ast::Label make_label(Label* old) {
90                return ast::Label(
91                        old->labelled->location,
92                        old->name,
93                        GET_ACCEPT_V(attributes, Attribute)
94                );
95        }
96
97        template<template <class...> class C>
98        C<ast::Label> make_labels(C<Label> olds) {
99                C<ast::Label> ret;
100                for (auto oldn : olds) {
101                        ret.push_back( make_label( &oldn ) );
102                }
103                return ret;
104        }
105
106#       define GET_LABELS_V(labels) \
107                to<std::vector>::from( make_labels( std::move( labels ) ) )
108
109        // Now all the visit functions:
110
111        virtual void visit( ObjectDecl * old ) override final {
112                auto decl = new ast::ObjectDecl(
113                        old->location,
114                        old->name,
115                        GET_ACCEPT_1(type, Type),
116                        GET_ACCEPT_1(init, Init),
117                        { old->get_storageClasses().val },
118                        { old->linkage.val },
119                        GET_ACCEPT_1(bitfieldWidth, Expr),
120                        GET_ACCEPT_V(attributes, Attribute),
121                        { old->get_funcSpec().val }
122                );
123                decl->scopeLevel = old->scopeLevel;
124                decl->mangleName = old->mangleName;
125                decl->isDeleted  = old->isDeleted;
126                decl->uniqueId   = old->uniqueId;
127                decl->extension  = old->extension;
128
129                this->node = decl;
130        }
131
132        virtual void visit( FunctionDecl * ) override final {
133
134        }
135
136        virtual void visit( StructDecl * old ) override final {
137                auto decl = new ast::StructDecl(
138                        old->location,
139                        old->name,
140                        old->kind,
141                        GET_ACCEPT_V(attributes, Attribute),
142                        { old->linkage.val }
143                );
144                decl->parent = GET_ACCEPT_1(parent, AggregateDecl);
145                decl->body   = old->body;
146                decl->params = GET_ACCEPT_V(parameters, TypeDecl);
147                decl->members    = GET_ACCEPT_V(members, Decl);
148                decl->extension  = old->extension;
149                decl->uniqueId   = old->uniqueId;
150                decl->storage    = { old->storageClasses.val };
151
152                this->node = decl;
153        }
154
155        virtual void visit( UnionDecl * old ) override final {
156                auto decl = new ast::UnionDecl(
157                        old->location,
158                        old->name,
159                        GET_ACCEPT_V(attributes, Attribute),
160                        { old->linkage.val }
161                );
162                decl->parent = GET_ACCEPT_1(parent, AggregateDecl);
163                decl->body   = old->body;
164                decl->params = GET_ACCEPT_V(parameters, TypeDecl);
165                decl->members    = GET_ACCEPT_V(members, Decl);
166                decl->extension  = old->extension;
167                decl->uniqueId   = old->uniqueId;
168                decl->storage    = { old->storageClasses.val };
169
170                this->node = decl;
171        }
172
173        virtual void visit( EnumDecl * old ) override final {
174                auto decl = new ast::UnionDecl(
175                        old->location,
176                        old->name,
177                        GET_ACCEPT_V(attributes, Attribute),
178                        { old->linkage.val }
179                );
180                decl->parent = GET_ACCEPT_1(parent, AggregateDecl);
181                decl->body   = old->body;
182                decl->params = GET_ACCEPT_V(parameters, TypeDecl);
183                decl->members    = GET_ACCEPT_V(members, Decl);
184                decl->extension  = old->extension;
185                decl->uniqueId   = old->uniqueId;
186                decl->storage    = { old->storageClasses.val };
187
188                this->node = decl;
189        }
190
191        virtual void visit( TraitDecl * old ) override final {
192                auto decl = new ast::UnionDecl(
193                        old->location,
194                        old->name,
195                        GET_ACCEPT_V(attributes, Attribute),
196                        { old->linkage.val }
197                );
198                decl->parent = GET_ACCEPT_1(parent, AggregateDecl);
199                decl->body   = old->body;
200                decl->params = GET_ACCEPT_V(parameters, TypeDecl);
201                decl->members    = GET_ACCEPT_V(members, Decl);
202                decl->extension  = old->extension;
203                decl->uniqueId   = old->uniqueId;
204                decl->storage    = { old->storageClasses.val };
205
206                this->node = decl;
207        }
208
209        virtual void visit( TypeDecl * ) override final {
210
211        }
212
213        virtual void visit( TypedefDecl * old ) override final {
214                auto decl = new ast::TypedefDecl(
215                        old->location,
216                        old->name,
217                        { old->storageClasses.val },
218                        GET_ACCEPT_1(base, Type),
219                        { old->linkage.val }
220                );
221                decl->assertions = GET_ACCEPT_V(assertions, DeclWithType);
222                decl->params     = GET_ACCEPT_V(parameters, TypeDecl);
223                decl->extension  = old->extension;
224                decl->uniqueId   = old->uniqueId;
225                decl->storage    = { old->storageClasses.val };
226
227                this->node = decl;
228        }
229
230        virtual void visit( AsmDecl * ) override final {
231
232        }
233
234        virtual void visit( StaticAssertDecl * ) override final {
235
236        }
237
238        virtual void visit( CompoundStmt * old ) override final {
239                auto stmt = new ast::CompoundStmt(
240                        old->location,
241                        to<std::list>::from( GET_ACCEPT_V(kids, Stmt) ),
242                        GET_LABELS_V(old->labels)
243                );
244
245                this->node = stmt;
246        }
247
248        virtual void visit( ExprStmt * old ) override final {
249                this->node = new ast::ExprStmt(
250                        old->location,
251                        GET_ACCEPT_1(expr, Expr),
252                        GET_LABELS_V(old->labels)
253                );
254        }
255
256        virtual void visit( AsmStmt * old ) override final {
257                this->node = new ast::AsmStmt(
258                        old->location,
259                        old->voltile,
260                        GET_ACCEPT_1(instruction, Expr),
261                        GET_ACCEPT_V(output, Expr),
262                        GET_ACCEPT_V(input, Expr),
263                        GET_ACCEPT_V(clobber, ConstantExpr),
264                        GET_LABELS_V(old->gotolabels),
265                        GET_LABELS_V(old->labels)
266                );
267        }
268
269        virtual void visit( DirectiveStmt * old ) override final {
270                this->node = new ast::DirectiveStmt(
271                        old->location,
272                        old->directive,
273                        GET_LABELS_V(old->labels)
274                );
275        }
276
277        virtual void visit( IfStmt * old ) override final {
278                this->node = new ast::IfStmt(
279                        old->location,
280                        GET_ACCEPT_1(condition, Expr),
281                        GET_ACCEPT_1(thenPart, Stmt),
282                        GET_ACCEPT_1(elsePart, Stmt),
283                        GET_ACCEPT_V(initialization, Stmt),
284                        GET_LABELS_V(old->labels)
285                );
286        }
287
288        virtual void visit( SwitchStmt * old ) override final {
289                this->node = new ast::SwitchStmt(
290                        old->location,
291                        GET_ACCEPT_1(condition, Expr),
292                        GET_ACCEPT_V(statements, Stmt),
293                        GET_LABELS_V(old->labels)
294                );
295        }
296
297        virtual void visit( CaseStmt * old ) override final {
298                this->node = new ast::CaseStmt(
299                        old->location,
300                        GET_ACCEPT_1(condition, Expr),
301                        GET_ACCEPT_V(stmts, Stmt),
302                        GET_LABELS_V(old->labels)
303                );
304        }
305
306        virtual void visit( WhileStmt * old ) override final {
307                this->node = new ast::WhileStmt(
308                        old->location,
309                        GET_ACCEPT_1(condition, Expr),
310                        GET_ACCEPT_1(body, Stmt),
311                        GET_ACCEPT_V(initialization, Stmt),
312                        old->isDoWhile,
313                        GET_LABELS_V(old->labels)
314                );
315        }
316
317        virtual void visit( ForStmt * old ) override final {
318                this->node = new ast::ForStmt(
319                        old->location,
320                        GET_ACCEPT_V(initialization, Stmt),
321                        GET_ACCEPT_1(condition, Expr),
322                        GET_ACCEPT_1(increment, Expr),
323                        GET_ACCEPT_1(body, Stmt),
324                        GET_LABELS_V(old->labels)
325                );
326        }
327
328        virtual void visit( BranchStmt * old ) override final {
329                if (old->computedTarget) {
330                        this->node = new ast::BranchStmt(
331                                old->location,
332                                GET_ACCEPT_1(computedTarget, Expr),
333                                GET_LABELS_V(old->labels)
334                        );
335                } else {
336                        ast::BranchStmt::Kind kind;
337                        switch (old->type) {
338                        #define CASE(n) \
339                        case BranchStmt::n: \
340                                kind = ast::BranchStmt::n; \
341                                break
342                        CASE(Goto);
343                        CASE(Break);
344                        CASE(Continue);
345                        CASE(FallThrough);
346                        CASE(FallThroughDefault);
347                        #undef CASE
348                        default:
349                                assertf(false, "Invalid BranchStmt::Type %d\n", old->type);
350                        }
351
352                        Label label = old->originalTarget;
353                        auto stmt = new ast::BranchStmt(
354                                old->location,
355                                kind,
356                                make_label(&label),
357                                GET_LABELS_V(old->labels)
358                        );
359                        stmt->target = make_label(&old->target);
360                        this->node = stmt;
361                }
362        }
363
364        virtual void visit( ReturnStmt * old ) override final {
365                this->node = new ast::ReturnStmt(
366                        old->location,
367                        GET_ACCEPT_1(expr, Expr),
368                        GET_LABELS_V(old->labels)
369                );
370        }
371
372        virtual void visit( ThrowStmt * old ) override final {
373                ast::ThrowStmt::Kind kind;
374                switch (old->kind) {
375                case ThrowStmt::Terminate:
376                        kind = ast::ThrowStmt::Terminate;
377                        break;
378                case ThrowStmt::Resume:
379                        kind = ast::ThrowStmt::Resume;
380                        break;
381                default:
382                        assertf(false, "Invalid ThrowStmt::Kind %d\n", old->kind);
383                }
384
385                this->node = new ast::ThrowStmt(
386                        old->location,
387                        kind,
388                        GET_ACCEPT_1(expr, Expr),
389                        GET_ACCEPT_1(target, Expr),
390                        GET_LABELS_V(old->labels)
391                );
392        }
393
394        virtual void visit( TryStmt * old ) override final {
395                this->node = new ast::TryStmt(
396                        old->location,
397                        GET_ACCEPT_1(block, CompoundStmt),
398                        GET_ACCEPT_V(handlers, CatchStmt),
399                        GET_ACCEPT_1(finallyBlock, FinallyStmt),
400                        GET_LABELS_V(old->labels)
401                );
402        }
403
404        virtual void visit( CatchStmt * old ) override final {
405                ast::CatchStmt::Kind kind;
406                switch (old->kind) {
407                case CatchStmt::Terminate:
408                        kind = ast::CatchStmt::Terminate;
409                        break;
410                case CatchStmt::Resume:
411                        kind = ast::CatchStmt::Resume;
412                        break;
413                default:
414                        assertf(false, "Invalid CatchStmt::Kind %d\n", old->kind);
415                }
416
417                this->node = new ast::CatchStmt(
418                        old->location,
419                        kind,
420                        GET_ACCEPT_1(decl, Decl),
421                        GET_ACCEPT_1(cond, Expr),
422                        GET_ACCEPT_1(body, Stmt),
423                        GET_LABELS_V(old->labels)
424                );
425        }
426
427        virtual void visit( FinallyStmt * old ) override final {
428                this->node = new ast::FinallyStmt(
429                        old->location,
430                        GET_ACCEPT_1(block, CompoundStmt),
431                        GET_LABELS_V(old->labels)
432                );
433        }
434
435        virtual void visit( WaitForStmt * old ) override final {
436                ast::WaitForStmt * stmt = new ast::WaitForStmt(
437                        old->location,
438                        GET_LABELS_V(old->labels)
439                );
440
441                stmt->clauses.reserve( old->clauses.size() );
442                for (size_t i = 0 ; i < old->clauses.size() ; ++i) {
443                        stmt->clauses.push_back({
444                                ast::WaitForStmt::Target{
445                                        GET_ACCEPT_1(clauses[i].target.function, Expr),
446                                        GET_ACCEPT_V(clauses[i].target.arguments, Expr)
447                                },
448                                GET_ACCEPT_1(clauses[i].statement, Stmt),
449                                GET_ACCEPT_1(clauses[i].condition, Expr)
450                        });
451                }
452                stmt->timeout = {
453                        GET_ACCEPT_1(timeout.time, Expr),
454                        GET_ACCEPT_1(timeout.statement, Stmt),
455                        GET_ACCEPT_1(timeout.condition, Expr),
456                };
457                stmt->orElse = {
458                        GET_ACCEPT_1(timeout.statement, Stmt),
459                        GET_ACCEPT_1(timeout.condition, Expr),
460                };
461
462                this->node = stmt;
463        }
464
465        virtual void visit( WithStmt * old ) override final {
466                this->node = new ast::WithStmt(
467                        old->location,
468                        GET_ACCEPT_V(exprs, Expr),
469                        GET_ACCEPT_1(stmt, Stmt),
470                        GET_LABELS_V(old->labels)
471                );
472        }
473
474        virtual void visit( NullStmt * old ) override final {
475                this->node = new ast::NullStmt(
476                        old->location,
477                        GET_LABELS_V(old->labels)
478                );
479        }
480
481        virtual void visit( DeclStmt * old ) override final {
482                this->node = new ast::DeclStmt(
483                        old->location,
484                        GET_ACCEPT_1(decl, Decl),
485                        GET_LABELS_V(old->labels)
486                );
487        }
488
489        virtual void visit( ImplicitCtorDtorStmt * old ) override final {
490                this->node = new ast::ImplicitCtorDtorStmt(
491                        old->location,
492                        GET_ACCEPT_1(callStmt, Stmt),
493                        GET_LABELS_V(old->labels)
494                );
495        }
496
497        virtual void visit( ApplicationExpr * ) override final {
498
499        }
500
501        virtual void visit( UntypedExpr * ) override final {
502
503        }
504
505        virtual void visit( NameExpr * ) override final {
506
507        }
508
509        virtual void visit( CastExpr * ) override final {
510
511        }
512
513        virtual void visit( KeywordCastExpr * ) override final {
514
515        }
516
517        virtual void visit( VirtualCastExpr * ) override final {
518
519        }
520
521        virtual void visit( AddressExpr * ) override final {
522
523        }
524
525        virtual void visit( LabelAddressExpr * ) override final {
526
527        }
528
529        virtual void visit( UntypedMemberExpr * ) override final {
530
531        }
532
533        virtual void visit( MemberExpr * ) override final {
534
535        }
536
537        virtual void visit( VariableExpr * ) override final {
538
539        }
540
541        virtual void visit( ConstantExpr * ) override final {
542
543        }
544
545        virtual void visit( SizeofExpr * ) override final {
546
547        }
548
549        virtual void visit( AlignofExpr * ) override final {
550
551        }
552
553        virtual void visit( UntypedOffsetofExpr * ) override final {
554
555        }
556
557        virtual void visit( OffsetofExpr * ) override final {
558
559        }
560
561        virtual void visit( OffsetPackExpr * ) override final {
562
563        }
564
565        virtual void visit( LogicalExpr * ) override final {
566
567        }
568
569        virtual void visit( ConditionalExpr * ) override final {
570
571        }
572
573        virtual void visit( CommaExpr * ) override final {
574
575        }
576
577        virtual void visit( TypeExpr * ) override final {
578
579        }
580
581        virtual void visit( AsmExpr * ) override final {
582
583        }
584
585        virtual void visit( ImplicitCopyCtorExpr * ) override final {
586
587        }
588
589        virtual void visit( ConstructorExpr *  ) override final {
590
591        }
592
593        virtual void visit( CompoundLiteralExpr * ) override final {
594
595        }
596
597        virtual void visit( RangeExpr * ) override final {
598
599        }
600
601        virtual void visit( UntypedTupleExpr * ) override final {
602
603        }
604
605        virtual void visit( TupleExpr * ) override final {
606
607        }
608
609        virtual void visit( TupleIndexExpr * ) override final {
610
611        }
612
613        virtual void visit( TupleAssignExpr * ) override final {
614
615        }
616
617        virtual void visit( StmtExpr *  ) override final {
618
619        }
620
621        virtual void visit( UniqueExpr *  ) override final {
622
623        }
624
625        virtual void visit( UntypedInitExpr *  ) override final {
626
627        }
628
629        virtual void visit( InitExpr *  ) override final {
630
631        }
632
633        virtual void visit( DeletedExpr * ) override final {
634
635        }
636
637        virtual void visit( DefaultArgExpr * ) override final {
638
639        }
640
641        virtual void visit( GenericExpr * ) override final {
642
643        }
644
645        virtual void visit( VoidType * ) override final {
646
647        }
648
649        virtual void visit( BasicType * ) override final {
650
651        }
652
653        virtual void visit( PointerType * ) override final {
654
655        }
656
657        virtual void visit( ArrayType * ) override final {
658
659        }
660
661        virtual void visit( ReferenceType * ) override final {
662
663        }
664
665        virtual void visit( QualifiedType * ) override final {
666
667        }
668
669        virtual void visit( FunctionType * ) override final {
670
671        }
672
673        virtual void visit( StructInstType * ) override final {
674
675        }
676
677        virtual void visit( UnionInstType * ) override final {
678
679        }
680
681        virtual void visit( EnumInstType * ) override final {
682
683        }
684
685        virtual void visit( TraitInstType * ) override final {
686
687        }
688
689        virtual void visit( TypeInstType * ) override final {
690
691        }
692
693        virtual void visit( TupleType * ) override final {
694
695        }
696
697        virtual void visit( TypeofType * ) override final {
698
699        }
700
701        virtual void visit( AttrType * ) override final {
702
703        }
704
705        virtual void visit( VarArgsType * ) override final {
706
707        }
708
709        virtual void visit( ZeroType * ) override final {
710
711        }
712
713        virtual void visit( OneType * ) override final {
714
715        }
716
717        virtual void visit( GlobalScopeType * ) override final {
718
719        }
720
721        virtual void visit( Designation * ) override final {
722
723        }
724
725        virtual void visit( SingleInit * ) override final {
726
727        }
728
729        virtual void visit( ListInit * ) override final {
730
731        }
732
733        virtual void visit( ConstructorInit * ) override final {
734
735        }
736
737        virtual void visit( Constant * ) override final {
738
739        }
740
741        virtual void visit( Attribute * ) override final {
742
743        }
744
745        virtual void visit( AttrExpr * ) override final {
746
747                assert( 0 );
748        }
749};
750
751#undef GET_LABELS_V
752#undef GET_ACCEPT_V
753#undef GET_ACCEPT_1
754
755std::list< ast::ptr< ast::Decl > > convert( const std::list< Declaration * > & translationUnit ) {
756        ConverterOldToNew c;
757        std::list< ast::ptr< ast::Decl > > decls;
758        for(auto d : translationUnit) {
759                d->accept( c );
760                decls.emplace_back( c.decl() );
761                delete d;
762        }
763        return decls;
764}
Note: See TracBrowser for help on using the repository browser.