Changeset 675d816


Ignore:
Timestamp:
May 17, 2019, 4:02:37 PM (3 years ago)
Author:
Andrew Beach <ajbeach@…>
Branches:
arm-eh, cleanup-dtors, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr
Children:
f6964ef
Parents:
74dbbf6
Message:

Utility for ConverterNewToOld? and most of the statements.

Location:
src/AST
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • src/AST/Convert.cpp

    r74dbbf6 r675d816  
    1010// Created On       : Thu May 09 15::37::05 2019
    1111// Last Modified By : Andrew Beach
    12 // Last Modified On : Fri May 17 12:13:00 2019
    13 // Update Count     : 3
     12// Last Modified On : Fri May 17 16:01:00 2019
     13// Update Count     : 4
    1414//
    1515
     
    4242//================================================================================================
    4343class ConverterNewToOld : public ast::Visitor {
     44        BaseSyntaxNode * node = nullptr;
     45
     46        template<typename T>
     47        struct Getter {
     48                ConverterNewToOld & visitor;
     49
     50                template<typename U>
     51                T * accept1( const ast::ptr<U> & ptr ) {
     52                        ptr->accept( visitor );
     53                        T * ret = strict_dynamic_cast< T * >( visitor.node );
     54                        visitor.node = nullptr;
     55                        return ret;
     56                }
     57
     58                template<typename U>
     59                std::list< T * > acceptL( const U & container ) {
     60                        std::list< T * > ret;
     61                        for (auto ptr : container ) {
     62                                ret.emplace_back( accept1( ptr ) );
     63                        }
     64                        return ret;
     65                }
     66        };
     67
     68    template<typename T>
     69    Getter<T> get() {
     70        return Getter<T>{ *this };
     71    }
     72
     73        Label makeLabel(Statement * labelled, const ast::Label& label) {
     74                return Label(
     75                        label.name,
     76                        labelled,
     77                        get<Attribute>().acceptL(label.attributes)
     78                );
     79        }
     80
     81        template<template <class...> class C>
     82        std::list<Label> makeLabelL(Statement * labelled, const C<ast::Label>& labels) {
     83                std::list<Label> ret;
     84                for (auto label : labels) {
     85                        ret.push_back( makeLabel(labelled, label) );
     86                }
     87                return ret;
     88        }
     89
    4490public:
    45         template<typename T>
    46         T * get() {
    47                 T * ret = strict_dynamic_cast< T * >( node );
    48                 node = nullptr;
    49                 return ret;
     91        Declaration * decl( const ast::Decl * declNode ) {
     92                return get<Declaration>().accept1( ast::ptr<ast::Decl>( declNode ) );
    5093        }
    5194
    5295private:
    53         BaseSyntaxNode * node = nullptr;
    54 
    55         // All the visit functions:
    56 
    5796        const ast::DeclWithType * visit( const ast::ObjectDecl * node ) override final {
    5897                (void)node;
     
    106145
    107146        const ast::CompoundStmt * visit( const ast::CompoundStmt * node ) override final {
    108                 (void)node;
     147                auto stmt = new CompoundStmt( get<Statement>().acceptL( node->kids ) );
     148                stmt->location = node->location;
     149                stmt->labels = makeLabelL( stmt, node->labels );
     150                this->node = stmt;
    109151                return nullptr;
    110152        }
    111153
    112154        const ast::Stmt * visit( const ast::ExprStmt * node ) override final {
    113                 (void)node;
     155                auto stmt = new ExprStmt( get<Expression>().accept1( node->expr ) );
     156                stmt->location = node->location;
     157                stmt->labels = makeLabelL( stmt, node->labels );
     158                this->node = stmt;
    114159                return nullptr;
    115160        }
    116161
    117162        const ast::Stmt * visit( const ast::AsmStmt * node ) override final {
    118                 (void)node;
     163                auto stmt = new AsmStmt(
     164                        node->isVolatile,
     165                        get<Expression>().accept1( node->instruction ),
     166                        get<Expression>().acceptL( node->output ),
     167                        get<Expression>().acceptL( node->input ),
     168                        get<ConstantExpr>().acceptL( node->clobber ),
     169                        makeLabelL( nullptr, node->gotoLabels ) // What are these labelling?
     170                );
     171                stmt->location = node->location;
     172                stmt->labels = makeLabelL( stmt, node->labels );
     173                this->node = stmt;
    119174                return nullptr;
    120175        }
    121176
    122177        const ast::Stmt * visit( const ast::DirectiveStmt * node ) override final {
    123                 (void)node;
     178                auto stmt = new DirectiveStmt( node->directive );
     179                stmt->location = node->location;
     180                stmt->labels = makeLabelL( stmt, node->labels );
     181                this->node = stmt;
    124182                return nullptr;
    125183        }
    126184
    127185        const ast::Stmt * visit( const ast::IfStmt * node ) override final {
    128                 (void)node;
     186                auto stmt = new IfStmt(
     187                        get<Expression>().accept1( node->cond ),
     188                        get<Statement>().accept1( node->thenPart ),
     189                        get<Statement>().accept1( node->elsePart ),
     190                        get<Statement>().acceptL( node->inits )
     191                );
     192                stmt->location = node->location;
     193                stmt->labels = makeLabelL( stmt, node->labels );
     194                this->node = stmt;
     195                return nullptr;
     196        }
     197
     198        const ast::Stmt * visit( const ast::SwitchStmt * node ) override final {
     199                auto stmt = new SwitchStmt(
     200                        get<Expression>().accept1( node->cond ),
     201                        get<Statement>().acceptL( node->stmts )
     202                );
     203                stmt->location = node->location;
     204                stmt->labels = makeLabelL( stmt, node->labels );
     205                this->node = stmt;
     206                return nullptr;
     207        }
     208
     209        const ast::Stmt * visit( const ast::CaseStmt * node ) override final {
     210                auto stmt = new CaseStmt(
     211                        get<Expression>().accept1( node->cond ),
     212                        get<Statement>().acceptL( node->stmts ),
     213                        node->isDefault()
     214                );
     215                stmt->location = node->location;
     216                stmt->labels = makeLabelL( stmt, node->labels );
     217                this->node = stmt;
    129218                return nullptr;
    130219        }
    131220
    132221        const ast::Stmt * visit( const ast::WhileStmt * node ) override final {
    133                 (void)node;
     222                auto inits = get<Statement>().acceptL( node->inits );
     223                auto stmt = new WhileStmt(
     224                        get<Expression>().accept1( node->cond ),
     225                        get<Statement>().accept1( node->body ),
     226                        inits,
     227                        node->isDoWhile
     228                );
     229                stmt->location = node->location;
     230                stmt->labels = makeLabelL( stmt, node->labels );
     231                this->node = stmt;
    134232                return nullptr;
    135233        }
    136234
    137235        const ast::Stmt * visit( const ast::ForStmt * node ) override final {
    138                 (void)node;
    139                 return nullptr;
    140         }
    141 
    142         const ast::Stmt * visit( const ast::SwitchStmt * node ) override final {
    143                 (void)node;
    144                 return nullptr;
    145         }
    146 
    147         const ast::Stmt * visit( const ast::CaseStmt * node ) override final {
    148                 (void)node;
     236                auto stmt = new ForStmt(
     237                        get<Statement>().acceptL( node->inits ),
     238                        get<Expression>().accept1( node->cond ),
     239                        get<Expression>().accept1( node->inc ),
     240                        get<Statement>().accept1( node->body )
     241                );
     242                stmt->location = node->location;
     243                stmt->labels = makeLabelL( stmt, node->labels );
     244                this->node = stmt;
    149245                return nullptr;
    150246        }
    151247
    152248        const ast::Stmt * visit( const ast::BranchStmt * node ) override final {
    153                 (void)node;
     249                BranchStmt * stmt;
     250                if (node->computedTarget) {
     251                        stmt = new BranchStmt( get<Expression>().accept1( node->computedTarget ),
     252                                BranchStmt::Goto );
     253                } else {
     254                        BranchStmt::Type type;
     255                        switch (node->kind) {
     256                        #define CASE(n) \
     257                        case ast::BranchStmt::n: \
     258                                type = BranchStmt::n; \
     259                                break
     260                        CASE(Goto);
     261                        CASE(Break);
     262                        CASE(Continue);
     263                        CASE(FallThrough);
     264                        CASE(FallThroughDefault);
     265                        #undef CASE
     266                        default:
     267                                assertf(false, "Invalid ast::BranchStmt::Kind: %d\n", node->kind);
     268                        }
     269
     270                        // The labels here are also weird.
     271                        stmt = new BranchStmt( makeLabel( nullptr, node->originalTarget ), type );
     272                        stmt->target = makeLabel( stmt, node->target );
     273                }
     274                stmt->location = node->location;
     275                stmt->labels = makeLabelL( stmt, node->labels );
     276                this->node = stmt;
    154277                return nullptr;
    155278        }
    156279
    157280        const ast::Stmt * visit( const ast::ReturnStmt * node ) override final {
    158                 (void)node;
     281                auto stmt = new ReturnStmt( get<Expression>().accept1( node->expr ) );
     282                stmt->location = node->location;
     283                stmt->labels = makeLabelL( stmt, node->labels );
     284                this->node = stmt;
    159285                return nullptr;
    160286        }
    161287
    162288        const ast::Stmt * visit( const ast::ThrowStmt * node ) override final {
    163                 (void)node;
     289                ThrowStmt::Kind kind;
     290                switch (node->kind) {
     291                case ast::ThrowStmt::Terminate:
     292                        kind = ThrowStmt::Terminate;
     293                        break;
     294                case ast::ThrowStmt::Resume:
     295                        kind = ThrowStmt::Resume;
     296                        break;
     297                default:
     298                        assertf(false, "Invalid ast::ThrowStmt::Kind: %d\n", node->kind);
     299                }
     300                auto stmt = new ThrowStmt(
     301                        kind,
     302                        get<Expression>().accept1( node->expr ),
     303                        get<Expression>().accept1( node->target )
     304                );
     305                stmt->location = node->location;
     306                stmt->labels = makeLabelL( stmt, node->labels );
     307                this->node = stmt;
    164308                return nullptr;
    165309        }
    166310
    167311        const ast::Stmt * visit( const ast::TryStmt * node ) override final {
    168                 (void)node;
     312                auto handlers = get<CatchStmt>().acceptL( node->handlers );
     313                auto stmt = new TryStmt(
     314                        get<CompoundStmt>().accept1( node->body ),
     315                        handlers,
     316                        get<FinallyStmt>().accept1( node->finally )
     317                );
     318                stmt->location = node->location;
     319                stmt->labels = makeLabelL( stmt, node->labels );
     320                this->node = stmt;
    169321                return nullptr;
    170322        }
    171323
    172324        const ast::Stmt * visit( const ast::CatchStmt * node ) override final {
    173                 (void)node;
     325                CatchStmt::Kind kind;
     326                switch (node->kind) {
     327                case ast::CatchStmt::Terminate:
     328                        kind = CatchStmt::Terminate;
     329                        break;
     330                case ast::CatchStmt::Resume:
     331                        kind = CatchStmt::Resume;
     332                        break;
     333                default:
     334                        assertf(false, "Invalid ast::CatchStmt::Kind: %d\n", node->kind);
     335                }
     336                auto stmt = new CatchStmt(
     337                        kind,
     338                        get<Declaration>().accept1( node->decl ),
     339                        get<Expression>().accept1( node->cond ),
     340                        get<Statement>().accept1( node->body )
     341                );
     342                stmt->location = node->location;
     343                stmt->labels = makeLabelL( stmt, node->labels );
     344                this->node = stmt;
    174345                return nullptr;
    175346        }
    176347
    177348        const ast::Stmt * visit( const ast::FinallyStmt * node ) override final {
    178                 (void)node;
     349                auto stmt = new FinallyStmt( get<CompoundStmt>().accept1( node->body ) );
     350                stmt->location = node->location;
     351                stmt->labels = makeLabelL( stmt, node->labels );
     352                this->node = stmt;
    179353                return nullptr;
    180354        }
    181355
    182356        const ast::Stmt * visit( const ast::WaitForStmt * node ) override final {
    183                 (void)node;
     357                auto stmt = new WaitForStmt;
     358                stmt->clauses.reserve( node->clauses.size() );
     359                for ( auto clause : node->clauses ) {
     360                        stmt->clauses.push_back({{
     361                                        get<Expression>().accept1( clause.target.function ),
     362                                        get<Expression>().acceptL( clause.target.arguments ),
     363                                },
     364                                get<Statement>().accept1( clause.stmt ),
     365                                get<Expression>().accept1( clause.cond ),
     366                        });
     367                }
     368                stmt->timeout = {
     369                        get<Expression>().accept1( node->timeout.time ),
     370                        get<Statement>().accept1( node->timeout.stmt ),
     371                        get<Expression>().accept1( node->timeout.cond ),
     372                };
     373                stmt->orelse = {
     374                        get<Statement>().accept1( node->orElse.stmt ),
     375                        get<Expression>().accept1( node->orElse.cond ),
     376                };
     377                stmt->location = node->location;
     378                stmt->labels = makeLabelL( stmt, node->labels );
     379                this->node = stmt;
    184380                return nullptr;
    185381        }
    186382
    187383        const ast::Stmt * visit( const ast::WithStmt * node ) override final {
    188                 (void)node;
     384                auto stmt = new WithStmt(
     385                        get<Expression>().acceptL( node->exprs ),
     386                        get<Statement>().accept1( node->stmt )
     387                );
     388                stmt->location = node->location;
     389                stmt->labels = makeLabelL( stmt, node->labels );
     390                this->node = stmt;
    189391                return nullptr;
    190392        }
    191393
    192394        const ast::NullStmt * visit( const ast::NullStmt * node ) override final {
    193                 (void)node;
     395                auto stmt = new NullStmt();
     396                stmt->location = node->location;
     397                stmt->labels = makeLabelL( stmt, node->labels );
     398                this->node = stmt;
    194399                return nullptr;
    195400        }
    196401
    197402        const ast::Stmt * visit( const ast::DeclStmt * node ) override final {
    198                 (void)node;
     403                auto stmt = new DeclStmt( get<Declaration>().accept1( node->decl ) );
     404                stmt->location = node->location;
     405                stmt->labels = makeLabelL( stmt, node->labels );
     406                this->node = stmt;
    199407                return nullptr;
    200408        }
     
    496704
    497705        const ast::Init * visit( const ast::ConstructorInit * node ) override final {
    498                 (void)node;
    499                 return nullptr;
    500         }
    501 
    502         const ast::Constant * visit( const ast::Constant * node ) override final {
    503706                (void)node;
    504707                return nullptr;
     
    520723        std::list< Declaration * > decls;
    521724        for(auto d : translationUnit) {
    522                 d->accept( c );
    523                 decls.emplace_back( c.get<Declaration>() );
     725                decls.emplace_back( c.decl( d ) );
    524726                delete d;
    525727        }
  • src/AST/Stmt.hpp

    r74dbbf6 r675d816  
    1010// Created On       : Wed May  8 13:00:00 2019
    1111// Last Modified By : Andrew Beach
    12 // Last Modified On : Fri May 17 10:03:00 2019
    13 // Update Count     : 4
     12// Last Modified On : Fri May 17 12:45:00 2019
     13// Update Count     : 5
    1414//
    1515
     
    175175        : Stmt(loc, std::move(labels)), cond(cond), stmts(std::move(stmts)) {}
    176176
    177         bool isDefault() { return !cond; }
     177        bool isDefault() const { return !cond; }
    178178
    179179        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
Note: See TracChangeset for help on using the changeset viewer.