Changes in src/InitTweak/InitTweak.cc [c1ed2ee:2d11663]

File:

• src/InitTweak/InitTweak.cc (modified) (11 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"
@@ -87 +84 @@
                 };
 
-                struct InitFlattener_old : public WithShortCircuiting {
+                struct InitFlattener : public WithShortCircuiting {
                         void previsit( SingleInit * singleInit ) {
                                 visit_children = false;
@@ -95 +92 @@
                 };
 
-                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_old> flattener;
+                PassVisitor<InitFlattener> flattener;
                 maybeAccept( init, flattener );
                 return flattener.pass.argList;
@@ -124 +112 @@
         }
 
-std::vector< ast::ptr< ast::Expr > > makeInitList( const ast::Init * init ) {
-        ast::Pass< InitFlattener_new > flattener;
-        maybe_accept( init, flattener );
-        return std::move( flattener.pass.argList );
-}
-
-        class InitExpander_old::ExpanderImpl {
+        class InitExpander::ExpanderImpl {
         public:
                 virtual ~ExpanderImpl() = default;
@@ -137 +119 @@
         };
 
-        class InitImpl_old : public InitExpander_old::ExpanderImpl {
+        class InitImpl : public InitExpander::ExpanderImpl {
         public:
-                InitImpl_old( Initializer * init ) : init( init ) {}
-                virtual ~InitImpl_old() = default;
+                InitImpl( Initializer * init ) : init( init ) {}
+                virtual ~InitImpl() = default;
 
                 virtual std::list< Expression * > next( __attribute((unused)) std::list< Expression * > & indices ) {
@@ -154 +136 @@
         };
 
-        class ExprImpl_old : public InitExpander_old::ExpanderImpl {
+        class ExprImpl : public InitExpander::ExpanderImpl {
         public:
-                ExprImpl_old( Expression * expr ) : arg( expr ) {}
-                virtual ~ExprImpl_old() { delete arg; }
+                ExprImpl( Expression * expr ) : arg( expr ) {}
+                virtual ~ExprImpl() { delete arg; }
 
                 virtual std::list< Expression * > next( std::list< Expression * > & indices ) {
@@ -181 +163 @@
         };
 
-        InitExpander_old::InitExpander_old( Initializer * init ) : expander( new InitImpl_old( init ) ) {}
-
-        InitExpander_old::InitExpander_old( Expression * expr ) : expander( new ExprImpl_old( expr ) ) {}
-
-        std::list< Expression * > InitExpander_old::operator*() {
+        InitExpander::InitExpander( Initializer * init ) : expander( new InitImpl( init ) ) {}
+
+        InitExpander::InitExpander( Expression * expr ) : expander( new ExprImpl( expr ) ) {}
+
+        std::list< Expression * > InitExpander::operator*() {
                 return cur;
         }
 
-        InitExpander_old & InitExpander_old::operator++() {
+        InitExpander & InitExpander::operator++() {
                 cur = expander->next( indices );
                 return *this;
@@ -195 +177 @@
 
         // use array indices list to build switch statement
-        void InitExpander_old::addArrayIndex( Expression * index, Expression * dimension ) {
+        void InitExpander::addArrayIndex( Expression * index, Expression * dimension ) {
                 indices.push_back( index );
                 indices.push_back( dimension );
         }
 
-        void InitExpander_old::clearArrayIndices() {
+        void InitExpander::clearArrayIndices() {
                 deleteAll( indices );
                 indices.clear();
         }
 
-        bool InitExpander_old::addReference() {
+        bool InitExpander::addReference() {
                 bool added = false;
                 for ( Expression *& expr : cur ) {
@@ -236 +218 @@
 
                 template< typename OutIterator >
-                void build( UntypedExpr * callExpr, InitExpander_old::IndexList::iterator idx, InitExpander_old::IndexList::iterator idxEnd, Initializer * init, OutIterator out ) {
+                void build( UntypedExpr * callExpr, InitExpander::IndexList::iterator idx, InitExpander::IndexList::iterator idxEnd, Initializer * init, OutIterator out ) {
                         if ( idx == idxEnd ) return;
                         Expression * index = *idx++;
@@ -293 +275 @@
         // remaining elements.
         // To accomplish this, generate switch statement, consuming all of expander's elements
-        Statement * InitImpl_old::buildListInit( UntypedExpr * dst, std::list< Expression * > & indices ) {
+        Statement * InitImpl::buildListInit( UntypedExpr * dst, std::list< Expression * > & indices ) {
                 if ( ! init ) return nullptr;
                 CompoundStmt * block = new CompoundStmt();
@@ -306 +288 @@
         }
 
-        Statement * ExprImpl_old::buildListInit( UntypedExpr *, std::list< Expression * > & ) {
+        Statement * ExprImpl::buildListInit( UntypedExpr *, std::list< Expression * > & ) {
                 return nullptr;
         }
 
-        Statement * InitExpander_old::buildListInit( UntypedExpr * dst ) {
+        Statement * InitExpander::buildListInit( UntypedExpr * dst ) {
                 return expander->buildListInit( dst, indices );
         }
-
-class InitExpander_new::ExpanderImpl {
-public:
-        virtual ~ExpanderImpl() = default;
-        virtual std::vector< ast::ptr< ast::Expr > > next( IndexList & indices ) = 0;
-        virtual ast::ptr< ast::Stmt > buildListInit( 
-                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;
-        public:
-                InitImpl_new( const ast::Init * i ) : init( i ) {}
-
-                std::vector< ast::ptr< ast::Expr > > next( InitExpander_new::IndexList & ) override {
-                        return makeInitList( init );
-                }
-                
-                ast::ptr< ast::Stmt > buildListInit( 
-                        ast::UntypedExpr * callExpr, InitExpander_new::IndexList & indices 
-                ) override {
-                        // 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;
-                        }
-                }
-        };
-
-        class ExprImpl_new final : public InitExpander_new::ExpanderImpl {
-                ast::ptr< ast::Expr > arg;
-        public:
-                ExprImpl_new( const ast::Expr * a ) : arg( a ) {}
-
-                std::vector< ast::ptr< ast::Expr > > next( 
-                        InitExpander_new::IndexList & indices 
-                ) override {
-                        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( 
-                        ast::UntypedExpr *, InitExpander_new::IndexList & 
-                ) override { 
-                        return {};
-                }
-        };
-} // anonymous namespace
-
-InitExpander_new::InitExpander_new( const ast::Init * init )
-: expander( new InitImpl_new{ init } ), crnt(), indices() {}
-
-InitExpander_new::InitExpander_new( const ast::Expr * expr )
-: expander( new ExprImpl_new{ expr } ), crnt(), indices() {}
-
-std::vector< ast::ptr< ast::Expr > > InitExpander_new::operator* () { return crnt; }
-
-InitExpander_new & InitExpander_new::operator++ () {
-        crnt = expander->next( indices );
-        return *this;
-}
-
-/// 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( ast::UntypedExpr * callExpr ) {
-        return expander->buildListInit( callExpr, indices );
-}
-
-void InitExpander_new::addArrayIndex( const ast::Expr * index, const ast::Expr * dimension ) {
-        indices.emplace_back( index );
-        indices.emplace_back( dimension );
-}
-
-void InitExpander_new::clearArrayIndices() { indices.clear(); }
-
-bool InitExpander_new::addReference() {
-        for ( ast::ptr< ast::Expr > & expr : crnt ) {
-                expr = new ast::AddressExpr{ expr };
-        }
-        return ! crnt.empty();
-}
 
         Type * getTypeofThis( FunctionType * ftype ) {