Changes in / [172d9342:f6964ef]

Location:

src/AST

Files:

• Convert.cpp (modified) (4 diffs)
• Stmt.hpp (modified) (2 diffs)

src/AST/Convert.cpp

@@ -10 +10 @@
 // Created On       : Thu May 09 15::37::05 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri May 17 12:13:00 2019
-// Update Count     : 3
+// Last Modified On : Fri May 17 16:01:00 2019
+// Update Count     : 4
 //
 
@@ -41 +41 @@
 //================================================================================================
 class ConverterNewToOld : public ast::Visitor {
+        BaseSyntaxNode * node = nullptr;
+
+        template<typename T>
+        struct Getter {
+                ConverterNewToOld & visitor;
+
+                template<typename U>
+                T * accept1( const ast::ptr<U> & ptr ) {
+                        ptr->accept( visitor );
+                        T * ret = strict_dynamic_cast< T * >( visitor.node );
+                        visitor.node = nullptr;
+                        return ret;
+                }
+
+                template<typename U>
+                std::list< T * > acceptL( const U & container ) {
+                        std::list< T * > ret;
+                        for (auto ptr : container ) {
+                                ret.emplace_back( accept1( ptr ) );
+                        }
+                        return ret;
+                }
+        };
+
+    template<typename T>
+    Getter<T> get() {
+        return Getter<T>{ *this };
+    }
+
+        Label makeLabel(Statement * labelled, const ast::Label& label) {
+                return Label(
+                        label.name,
+                        labelled,
+                        get<Attribute>().acceptL(label.attributes)
+                );
+        }
+
+        template<template <class...> class C>
+        std::list<Label> makeLabelL(Statement * labelled, const C<ast::Label>& labels) {
+                std::list<Label> ret;
+                for (auto label : labels) {
+                        ret.push_back( makeLabel(labelled, label) );
+                }
+                return ret;
+        }
+
 public:
-        template<typename T>
-        T * get() {
-                T * ret = strict_dynamic_cast< T * >( node );
-                node = nullptr;
-                return ret;
+        Declaration * decl( const ast::Decl * declNode ) {
+                return get<Declaration>().accept1( ast::ptr<ast::Decl>( declNode ) );
         }
 
 private:
-        BaseSyntaxNode * node = nullptr;
-
-        // All the visit functions:
-
         const ast::DeclWithType * visit( const ast::ObjectDecl * node ) override final {
                 (void)node;
@@ -105 +144 @@
 
         const ast::CompoundStmt * visit( const ast::CompoundStmt * node ) override final {
-                (void)node;
+                auto stmt = new CompoundStmt( get<Statement>().acceptL( node->kids ) );
+                stmt->location = node->location;
+                stmt->labels = makeLabelL( stmt, node->labels );
+                this->node = stmt;
                 return nullptr;
         }
 
         const ast::Stmt * visit( const ast::ExprStmt * node ) override final {
-                (void)node;
+                auto stmt = new ExprStmt( get<Expression>().accept1( node->expr ) );
+                stmt->location = node->location;
+                stmt->labels = makeLabelL( stmt, node->labels );
+                this->node = stmt;
                 return nullptr;
         }
 
         const ast::Stmt * visit( const ast::AsmStmt * node ) override final {
-                (void)node;
+                auto stmt = new AsmStmt(
+                        node->isVolatile,
+                        get<Expression>().accept1( node->instruction ),
+                        get<Expression>().acceptL( node->output ),
+                        get<Expression>().acceptL( node->input ),
+                        get<ConstantExpr>().acceptL( node->clobber ),
+                        makeLabelL( nullptr, node->gotoLabels ) // What are these labelling?
+                );
+                stmt->location = node->location;
+                stmt->labels = makeLabelL( stmt, node->labels );
+                this->node = stmt;
                 return nullptr;
         }
 
         const ast::Stmt * visit( const ast::DirectiveStmt * node ) override final {
-                (void)node;
+                auto stmt = new DirectiveStmt( node->directive );
+                stmt->location = node->location;
+                stmt->labels = makeLabelL( stmt, node->labels );
+                this->node = stmt;
                 return nullptr;
         }
 
         const ast::Stmt * visit( const ast::IfStmt * node ) override final {
-                (void)node;
+                auto stmt = new IfStmt(
+                        get<Expression>().accept1( node->cond ),
+                        get<Statement>().accept1( node->thenPart ),
+                        get<Statement>().accept1( node->elsePart ),
+                        get<Statement>().acceptL( node->inits )
+                );
+                stmt->location = node->location;
+                stmt->labels = makeLabelL( stmt, node->labels );
+                this->node = stmt;
+                return nullptr;
+        }
+
+        const ast::Stmt * visit( const ast::SwitchStmt * node ) override final {
+                auto stmt = new SwitchStmt(
+                        get<Expression>().accept1( node->cond ),
+                        get<Statement>().acceptL( node->stmts )
+                );
+                stmt->location = node->location;
+                stmt->labels = makeLabelL( stmt, node->labels );
+                this->node = stmt;
+                return nullptr;
+        }
+
+        const ast::Stmt * visit( const ast::CaseStmt * node ) override final {
+                auto stmt = new CaseStmt(
+                        get<Expression>().accept1( node->cond ),
+                        get<Statement>().acceptL( node->stmts ),
+                        node->isDefault()
+                );
+                stmt->location = node->location;
+                stmt->labels = makeLabelL( stmt, node->labels );
+                this->node = stmt;
                 return nullptr;
         }
 
         const ast::Stmt * visit( const ast::WhileStmt * node ) override final {
-                (void)node;
+                auto inits = get<Statement>().acceptL( node->inits );
+                auto stmt = new WhileStmt(
+                        get<Expression>().accept1( node->cond ),
+                        get<Statement>().accept1( node->body ),
+                        inits,
+                        node->isDoWhile
+                );
+                stmt->location = node->location;
+                stmt->labels = makeLabelL( stmt, node->labels );
+                this->node = stmt;
                 return nullptr;
         }
 
         const ast::Stmt * visit( const ast::ForStmt * node ) override final {
-                (void)node;
-                return nullptr;
-        }
-
-        const ast::Stmt * visit( const ast::SwitchStmt * node ) override final {
-                (void)node;
-                return nullptr;
-        }
-
-        const ast::Stmt * visit( const ast::CaseStmt * node ) override final {
-                (void)node;
+                auto stmt = new ForStmt(
+                        get<Statement>().acceptL( node->inits ),
+                        get<Expression>().accept1( node->cond ),
+                        get<Expression>().accept1( node->inc ),
+                        get<Statement>().accept1( node->body )
+                );
+                stmt->location = node->location;
+                stmt->labels = makeLabelL( stmt, node->labels );
+                this->node = stmt;
                 return nullptr;
         }
 
         const ast::Stmt * visit( const ast::BranchStmt * node ) override final {
-                (void)node;
+                BranchStmt * stmt;
+                if (node->computedTarget) {
+                        stmt = new BranchStmt( get<Expression>().accept1( node->computedTarget ),
+                                BranchStmt::Goto );
+                } else {
+                        BranchStmt::Type type;
+                        switch (node->kind) {
+                        #define CASE(n) \
+                        case ast::BranchStmt::n: \
+                                type = BranchStmt::n; \
+                                break
+                        CASE(Goto);
+                        CASE(Break);
+                        CASE(Continue);
+                        CASE(FallThrough);
+                        CASE(FallThroughDefault);
+                        #undef CASE
+                        default:
+                                assertf(false, "Invalid ast::BranchStmt::Kind: %d\n", node->kind);
+                        }
+
+                        // The labels here are also weird.
+                        stmt = new BranchStmt( makeLabel( nullptr, node->originalTarget ), type );
+                        stmt->target = makeLabel( stmt, node->target );
+                }
+                stmt->location = node->location;
+                stmt->labels = makeLabelL( stmt, node->labels );
+                this->node = stmt;
                 return nullptr;
         }
 
         const ast::Stmt * visit( const ast::ReturnStmt * node ) override final {
-                (void)node;
+                auto stmt = new ReturnStmt( get<Expression>().accept1( node->expr ) );
+                stmt->location = node->location;
+                stmt->labels = makeLabelL( stmt, node->labels );
+                this->node = stmt;
                 return nullptr;
         }
 
         const ast::Stmt * visit( const ast::ThrowStmt * node ) override final {
-                (void)node;
+                ThrowStmt::Kind kind;
+                switch (node->kind) {
+                case ast::ThrowStmt::Terminate:
+                        kind = ThrowStmt::Terminate;
+                        break;
+                case ast::ThrowStmt::Resume:
+                        kind = ThrowStmt::Resume;
+                        break;
+                default:
+                        assertf(false, "Invalid ast::ThrowStmt::Kind: %d\n", node->kind);
+                }
+                auto stmt = new ThrowStmt(
+                        kind,
+                        get<Expression>().accept1( node->expr ),
+                        get<Expression>().accept1( node->target )
+                );
+                stmt->location = node->location;
+                stmt->labels = makeLabelL( stmt, node->labels );
+                this->node = stmt;
                 return nullptr;
         }
 
         const ast::Stmt * visit( const ast::TryStmt * node ) override final {
-                (void)node;
+                auto handlers = get<CatchStmt>().acceptL( node->handlers );
+                auto stmt = new TryStmt(
+                        get<CompoundStmt>().accept1( node->body ),
+                        handlers,
+                        get<FinallyStmt>().accept1( node->finally )
+                );
+                stmt->location = node->location;
+                stmt->labels = makeLabelL( stmt, node->labels );
+                this->node = stmt;
                 return nullptr;
         }
 
         const ast::Stmt * visit( const ast::CatchStmt * node ) override final {
-                (void)node;
+                CatchStmt::Kind kind;
+                switch (node->kind) {
+                case ast::CatchStmt::Terminate:
+                        kind = CatchStmt::Terminate;
+                        break;
+                case ast::CatchStmt::Resume:
+                        kind = CatchStmt::Resume;
+                        break;
+                default:
+                        assertf(false, "Invalid ast::CatchStmt::Kind: %d\n", node->kind);
+                }
+                auto stmt = new CatchStmt(
+                        kind,
+                        get<Declaration>().accept1( node->decl ),
+                        get<Expression>().accept1( node->cond ),
+                        get<Statement>().accept1( node->body )
+                );
+                stmt->location = node->location;
+                stmt->labels = makeLabelL( stmt, node->labels );
+                this->node = stmt;
                 return nullptr;
         }
 
         const ast::Stmt * visit( const ast::FinallyStmt * node ) override final {
-                (void)node;
+                auto stmt = new FinallyStmt( get<CompoundStmt>().accept1( node->body ) );
+                stmt->location = node->location;
+                stmt->labels = makeLabelL( stmt, node->labels );
+                this->node = stmt;
                 return nullptr;
         }
 
         const ast::Stmt * visit( const ast::WaitForStmt * node ) override final {
-                (void)node;
+                auto stmt = new WaitForStmt;
+                stmt->clauses.reserve( node->clauses.size() );
+                for ( auto clause : node->clauses ) {
+                        stmt->clauses.push_back({{
+                                        get<Expression>().accept1( clause.target.function ),
+                                        get<Expression>().acceptL( clause.target.arguments ),
+                                },
+                                get<Statement>().accept1( clause.stmt ),
+                                get<Expression>().accept1( clause.cond ),
+                        });
+                }
+                stmt->timeout = {
+                        get<Expression>().accept1( node->timeout.time ),
+                        get<Statement>().accept1( node->timeout.stmt ),
+                        get<Expression>().accept1( node->timeout.cond ),
+                };
+                stmt->orelse = {
+                        get<Statement>().accept1( node->orElse.stmt ),
+                        get<Expression>().accept1( node->orElse.cond ),
+                };
+                stmt->location = node->location;
+                stmt->labels = makeLabelL( stmt, node->labels );
+                this->node = stmt;
                 return nullptr;
         }
 
         const ast::Stmt * visit( const ast::WithStmt * node ) override final {
-                (void)node;
+                auto stmt = new WithStmt(
+                        get<Expression>().acceptL( node->exprs ),
+                        get<Statement>().accept1( node->stmt )
+                );
+                stmt->location = node->location;
+                stmt->labels = makeLabelL( stmt, node->labels );
+                this->node = stmt;
                 return nullptr;
         }
 
         const ast::NullStmt * visit( const ast::NullStmt * node ) override final {
-                (void)node;
+                auto stmt = new NullStmt();
+                stmt->location = node->location;
+                stmt->labels = makeLabelL( stmt, node->labels );
+                this->node = stmt;
                 return nullptr;
         }
 
         const ast::Stmt * visit( const ast::DeclStmt * node ) override final {
-                (void)node;
+                auto stmt = new DeclStmt( get<Declaration>().accept1( node->decl ) );
+                stmt->location = node->location;
+                stmt->labels = makeLabelL( stmt, node->labels );
+                this->node = stmt;
                 return nullptr;
         }
@@ -514 +722 @@
         std::list< Declaration * > decls;
         for(auto d : translationUnit) {
-                d->accept( c );
-                decls.emplace_back( c.get<Declaration>() );
+                decls.emplace_back( c.decl( d ) );
                 delete d;
         }

src/AST/Stmt.hpp

@@ -10 +10 @@
 // Created On       : Wed May  8 13:00:00 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri May 17 10:03:00 2019
-// Update Count     : 4
+// Last Modified On : Fri May 17 12:45:00 2019
+// Update Count     : 5
 //
 
@@ -175 +175 @@
         : Stmt(loc, std::move(labels)), cond(cond), stmts(std::move(stmts)) {}
 
-        bool isDefault() { return !cond; }
+        bool isDefault() const { return !cond; }
 
         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }