Changeset c1ed2ee for src/InitTweak/InitTweak.cc

Timestamp:

Jun 21, 2019, 3:41:36 PM (5 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

8d61d620

Parents:

9af00d23

Message:

Continued resolver porting

• mostly initialization and validation
• added move() and copy() to utility.h

File:

• src/InitTweak/InitTweak.cc (modified) (8 diffs)

src/InitTweak/InitTweak.cc

@@ -22 +22 @@
 
 #include "AST/Expr.hpp"
+#include "AST/Init.hpp"
 #include "AST/Node.hpp"
+#include "AST/Pass.hpp"
 #include "AST/Stmt.hpp"
 #include "AST/Type.hpp"
@@ -85 +87 @@
                 };
 
-                struct InitFlattener : public WithShortCircuiting {
+                struct InitFlattener_old : public WithShortCircuiting {
                         void previsit( SingleInit * singleInit ) {
                                 visit_children = false;
@@ -93 +95 @@
                 };
 
-        }
+                struct InitFlattener_new : public ast::WithShortCircuiting {
+                        std::vector< ast::ptr< ast::Expr > > argList;
+
+                        void previsit( const ast::SingleInit * singleInit ) {
+                                visit_children = false;
+                                argList.emplace_back( singleInit->value );
+                        }
+                };
+
+        } // anonymous namespace
 
         std::list< Expression * > makeInitList( Initializer * init ) {
-                PassVisitor<InitFlattener> flattener;
+                PassVisitor<InitFlattener_old> flattener;
                 maybeAccept( init, flattener );
                 return flattener.pass.argList;
@@ -114 +125 @@
 
 std::vector< ast::ptr< ast::Expr > > makeInitList( const ast::Init * init ) {
-        #warning unimplmented
-        (void)init;
-        assert(false);
-        return {};
+        ast::Pass< InitFlattener_new > flattener;
+        maybe_accept( init, flattener );
+        return std::move( flattener.pass.argList );
 }
 
@@ -309 +319 @@
         virtual std::vector< ast::ptr< ast::Expr > > next( IndexList & indices ) = 0;
         virtual ast::ptr< ast::Stmt > buildListInit( 
-                const ast::UntypedExpr * callExpr, IndexList & indices ) = 0;
+                ast::UntypedExpr * callExpr, IndexList & indices ) = 0;
 };
 
 namespace {
+        template< typename Out >
+        void buildCallExpr( 
+                ast::UntypedExpr * callExpr, const ast::Expr * index, const ast::Expr * dimension, 
+                const ast::Init * init, Out & out
+        ) {
+                const CodeLocation & loc = init->location;
+
+                auto cond = new ast::UntypedExpr{ 
+                        loc, new ast::NameExpr{ loc, "?<?" }, { index, dimension } };
+                
+                std::vector< ast::ptr< ast::Expr > > args = makeInitList( init );
+                splice( callExpr->args, args );
+
+                out.emplace_back( new ast::IfStmt{ loc, cond, new ast::ExprStmt{ loc, callExpr } } );
+
+                out.emplace_back( new ast::ExprStmt{ 
+                        loc, new ast::UntypedExpr{ loc, new ast::NameExpr{ loc, "++?" }, { index } } } );
+        }
+
+        template< typename Out >
+        void build(
+                ast::UntypedExpr * callExpr, const InitExpander_new::IndexList & indices, 
+                const ast::Init * init, Out & out
+        ) {
+                if ( indices.empty() ) return;
+
+                unsigned idx = 0;
+
+                const ast::Expr * index = indices[idx++];
+                assert( idx != indices.size() );
+                const ast::Expr * dimension = indices[idx++];
+
+                if ( idx == indices.size() ) {
+                        if ( auto listInit = dynamic_cast< const ast::ListInit * >( init ) ) {
+                                for ( const ast::Init * init : *listInit ) {
+                                        buildCallExpr( callExpr, index, dimension, init, out );
+                                }
+                        } else {
+                                buildCallExpr( callExpr, index, dimension, init, out );
+                        }
+                } else {
+                        const CodeLocation & loc = init->location;
+
+                        unsigned long cond = 0;
+                        auto listInit = dynamic_cast< const ast::ListInit * >( init );
+                        if ( ! listInit ) { SemanticError( loc, "unbalanced list initializers" ); }
+
+                        static UniqueName targetLabel( "L__autogen__" );
+                        ast::Label switchLabel{ 
+                                loc, targetLabel.newName(), { new ast::Attribute{ "unused" } } };
+                        
+                        std::vector< ast::ptr< ast::Stmt > > branches;
+                        for ( const ast::Init * init : *listInit ) {
+                                auto condition = ast::ConstantExpr::from_ulong( loc, cond );
+                                ++cond;
+
+                                std::vector< ast::ptr< ast::Stmt > > stmts;
+                                build( callExpr, indices, init, stmts );
+                                stmts.emplace_back( 
+                                        new ast::BranchStmt{ loc, ast::BranchStmt::Break, switchLabel } );
+                                branches.emplace_back( new ast::CaseStmt{ loc, condition, std::move( stmts ) } );
+                        }
+                        out.emplace_back( new ast::SwitchStmt{ loc, index, std::move( branches ) } );
+                        out.emplace_back( new ast::NullStmt{ loc, { switchLabel } } );
+                }
+        }
+
         class InitImpl_new final : public InitExpander_new::ExpanderImpl {
                 ast::ptr< ast::Init > init;
@@ -323 +400 @@
                 
                 ast::ptr< ast::Stmt > buildListInit( 
-                        const ast::UntypedExpr * callExpr, InitExpander_new::IndexList & indices 
+                        ast::UntypedExpr * callExpr, InitExpander_new::IndexList & indices 
                 ) override {
-                        #warning unimplemented
-                        (void)callExpr; (void)indices;
-                        assert(false);
-                        return {};
+                        // If array came with an initializer list, initialize each element. We may have more 
+                        // initializers than elements of the array; need to check at each index that we have 
+                        // not exceeded size. We may have fewer initializers than elements in the array; need 
+                        // to default-construct remaining elements. To accomplish this, generate switch 
+                        // statement consuming all of expander's elements
+
+                        if ( ! init ) return {};
+
+                        std::list< ast::ptr< ast::Stmt > > stmts;
+                        build( callExpr, indices, init, stmts );
+                        if ( stmts.empty() ) {
+                                return {};
+                        } else {
+                                auto block = new ast::CompoundStmt{ init->location, std::move( stmts ) };
+                                init = nullptr;  // consumed in creating the list init
+                                return block;
+                        }
                 }
         };
@@ -340 +430 @@
                         InitExpander_new::IndexList & indices 
                 ) override {
-                        #warning unimplemented
-                        (void)indices;
-                        assert(false);
-                        return {};
+                        if ( ! arg ) return {};
+
+                        const CodeLocation & loc = arg->location;
+                        const ast::Expr * expr = arg;
+                        for ( auto it = indices.rbegin(); it != indices.rend(); ++it ) {
+                                // go through indices and layer on subscript exprs ?[?]
+                                ++it;
+                                expr = new ast::UntypedExpr{ 
+                                        loc, new ast::NameExpr{ loc, "?[?]" }, { expr, *it } };
+                        }
+                        return { expr };
                 }
                 
                 ast::ptr< ast::Stmt > buildListInit( 
-                        const ast::UntypedExpr *, InitExpander_new::IndexList & 
+                        ast::UntypedExpr *, InitExpander_new::IndexList & 
                 ) override { 
                         return {};
@@ -369 +466 @@
 /// builds statement which has the same semantics as a C-style list initializer (for array 
 /// initializers) using callExpr as the base expression to perform initialization
-ast::ptr< ast::Stmt > InitExpander_new::buildListInit( const ast::UntypedExpr * callExpr ) {
+ast::ptr< ast::Stmt > InitExpander_new::buildListInit( ast::UntypedExpr * callExpr ) {
         return expander->buildListInit( callExpr, indices );
 }