Changeset 39f84a4 for src/InitTweak

Timestamp:

Jul 29, 2016, 11:40:28 AM (9 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

4d2434a

Parents:

29e8bf5

Message:

part-way through reorganizing ctor call generation so that it is more general

Location:

src/InitTweak

Files:

• GenInit.cc (modified) (1 diff)
• InitTweak.cc (modified) (4 diffs)
• InitTweak.h (modified) (1 diff)

src/InitTweak/GenInit.cc ¶

@@ -225 +225 @@
                                         std::list< Statement * > dtor;
 
-                                        SymTab::genImplicitCall( NULL, new VariableExpr( objDecl ), "?{}", back_inserter( ctor ), objDecl );
-                                        SymTab::genImplicitCall( NULL, new VariableExpr( objDecl ), "^?{}", front_inserter( dtor ), objDecl, false );
+                                        InitExpander srcParam( (Expression *)NULL );
+                                        SymTab::genImplicitCall( srcParam, new VariableExpr( objDecl ), "?{}", back_inserter( ctor ), objDecl );
+                                        SymTab::genImplicitCall( srcParam, new VariableExpr( objDecl ), "^?{}", front_inserter( dtor ), objDecl, false );
 
                                         // Currently genImplicitCall produces a single Statement - a CompoundStmt

src/InitTweak/InitTweak.cc ¶

@@ -20 +20 @@
                 };
 
-                class InitExpander : public Visitor {
+                class InitExpander_OLD : public Visitor {
                         public:
-                        InitExpander() {}
                         virtual void visit( SingleInit * singleInit );
                         virtual void visit( ListInit * listInit );
@@ -28 +27 @@
                 };
 
-                void InitExpander::visit( SingleInit * singleInit ) {
+                void InitExpander_OLD::visit( SingleInit * singleInit ) {
                         argList.push_back( singleInit->get_value()->clone() );
                 }
 
-                void InitExpander::visit( ListInit * listInit ) {
+                void InitExpander_OLD::visit( ListInit * listInit ) {
                         // xxx - for now, assume no nested list inits
                         std::list<Initializer*>::iterator it = listInit->begin_initializers();
@@ -42 +41 @@
 
         std::list< Expression * > makeInitList( Initializer * init ) {
-                InitExpander expander;
+                InitExpander_OLD expander;
                 maybeAccept( init, expander );
                 return expander.argList;
@@ -51 +50 @@
                 maybeAccept( init, finder );
                 return finder.hasDesignations;
+        }
+
+        class InitExpander::ExpanderImpl {
+        public:
+                virtual std::list< Expression * > next( std::list< Expression * > & indices ) = 0;
+        };
+
+        class InitImpl : public InitExpander::ExpanderImpl {
+        public:
+                InitImpl( Initializer * init ) {
+                        if ( init ) inits.push_back( init );
+                }
+
+                virtual std::list< Expression * > next( std::list< Expression * > & indices ) {
+                        // this is wrong, but just a placeholder for now
+                        return ! inits.empty() ? makeInitList( inits.front() ) : std::list< Expression * >();
+                }
+        private:
+                std::list< Initializer * > inits;
+        };
+
+        class ExprImpl : public InitExpander::ExpanderImpl {
+        public:
+                ExprImpl( Expression * expr ) : arg( expr ) {}
+
+                virtual std::list< Expression * > next( std::list< Expression * > & indices ) {
+                        std::list< Expression * > ret;
+                        Expression * expr = maybeClone( arg );
+                        if ( expr ) {
+                                for ( std::list< Expression * >::reverse_iterator it = indices.rbegin(); it != indices.rend(); ++it ) {
+                                        // go through indices and layer on subscript exprs ?[?]
+                                        ++it;
+                                        UntypedExpr * subscriptExpr = new UntypedExpr( new NameExpr( "?[?]") );
+                                        subscriptExpr->get_args().push_back( expr );
+                                        subscriptExpr->get_args().push_back( (*it)->clone() );
+                                        expr = subscriptExpr;
+                                }
+                                ret.push_back( expr );
+                        }
+                        return ret;
+                }
+        private:
+                Expression * arg;
+        };
+
+        InitExpander::InitExpander( Initializer * init ) : expander( new InitImpl( init ) ) {}
+
+        InitExpander::InitExpander( Expression * expr ) : expander( new ExprImpl( expr ) ) {}
+
+        std::list< Expression * > InitExpander::operator*() {
+                return cur;
+        }
+
+        InitExpander & InitExpander::operator++() {
+                cur = expander->next( indices );
+                return *this;
+        }
+
+        // use array indices list to build switch statement
+        void InitExpander::addArrayIndex( Expression * index, Expression * dimension ) {
+                indices.push_back( index );
+                indices.push_back( dimension );
+        }
+
+        template< typename OutIterator >
+        void build( UntypedExpr * callExpr, InitExpander::IndexList::iterator idx, InitExpander::IndexList::iterator end, OutIterator out ) {
+                if ( idx == end ) return;
+                Expression * index = *idx++;
+                assert( idx != end );
+                Expression * dimension = *idx++;
+
+                // if ( idx == end ) {
+                //      // loop through list of expressions belonging to the current initializer
+                //      UntypedExpr * cond = new UntypedExpr( new NameExpr( "?<?") );
+                //      cond->get_args().push_back( index->clone() );
+                //      cond->get_args().push_back( dimension->clone() );
+
+                //      UntypedExpr * call = callExpr->clone();
+                //      std::list< Expression * > args = *++expander; // xxx - need a way to indentify the end of an init list
+                //      call->get_args().splice( args );
+
+                //      *out++ = new IfStmt( noLabels, cond, new ExprStmt( call ), NULL );
+
+                //      UntypedExpr * increment = new UntypedExpr( new NameExpr( "++?" ) );
+                //      increment->get_args().push_back( index->clone() );
+                //      *out++ = new ExprStmt( increment );
+                // } else {
+                //      std::list< Statement * > branches;
+                //      for (...) { // loop over conditions?
+                //              std::list< Statement * > stmts;
+                //              build( idx, end, back_inserter( stmts ) );
+                //              CaseStmt * caseStmt = new CaseStmt( noLabels, condition, stmts );
+                //              branches.push_back( caseStmt );
+                //      }
+                //      *out++ = new SwitchStmt( noLabels, index->clone(), branches );
+                // }
+        }
+
+        // generate switch statement, consuming all of expander's elements
+        Statement * InitExpander::buildListInit( UntypedExpr * dst ) {
+                std::list< Statement * > results;
+                build( dst, indices.begin(), indices.end(), back_inserter( results ) );
+                assert( results.size() <= 1 );
+                return ! results.empty() ? results.front() : NULL;
         }
 

src/InitTweak/InitTweak.h ¶

@@ -61 +61 @@
         bool isConstExpr( Expression * expr );
         bool isConstExpr( Initializer * init );
+
+        class InitExpander {
+        public:
+                // expand by stepping through init to get each list of arguments
+                InitExpander( Initializer * init );
+
+                // always expand to expr
+                InitExpander( Expression * expr );
+
+                // iterator-like interface
+                std::list< Expression * > operator*();
+                InitExpander & operator++();
+
+                // 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
+                Statement * buildListInit( UntypedExpr * callExpr );
+                void addArrayIndex( Expression * index, Expression * dimension );
+
+                class ExpanderImpl;
+        private:
+                std::shared_ptr< ExpanderImpl > expander;
+                std::list< Expression * > cur;
+
+                // invariant: list of size 2N (elements come in pairs [index, dimension])
+                typedef std::list< Expression * > IndexList;
+                IndexList indices;
+        };
 } // namespace