Changeset 39786813 for src/InitTweak

Timestamp:

Mar 31, 2016, 2:33:49 PM (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, gc_noraii, 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:

a5a71d0

Parents:

e0323a2

Message:

generate appropriate destructor calls before return, break, and continue statements (todo: goto, labelled break/continue)

File:

• src/InitTweak/FixInit.cc (modified) (5 diffs)

src/InitTweak/FixInit.cc

@@ -10 +10 @@
 // Created On       : Wed Jan 13 16:29:30 2016
 // Last Modified By : Rob Schluntz
-// Last Modified On : Thu Mar 31 10:08:49 2016
+// Last Modified On : Thu Mar 31 13:54:58 2016
 // Update Count     : 30
 //
@@ -38 +38 @@
 
                 virtual CompoundStmt * mutate( CompoundStmt * compoundStmt );
+                virtual Statement * mutate( ReturnStmt * returnStmt );
+                virtual Statement * mutate( BranchStmt * branchStmt );
 
           private:
-                std::list< Statement * > dtorStmts;
+                // stack of list of statements - used to differentiate scopes
+                std::list< std::list< Statement * > > dtorStmts;
         };
 
@@ -103 +106 @@
                                 } else {
                                         stmtsToAddAfter.push_back( ctor );
-                                        dtorStmts.push_front( ctorInit->get_dtor() );
+                                        dtorStmts.back().push_front( ctorInit->get_dtor() );
                                 }
                                 objDecl->set_init( NULL );
@@ -120 +123 @@
         }
 
-        CompoundStmt * FixInit::mutate( CompoundStmt * compoundStmt ) {
-                // mutate statements - this will also populate dtorStmts list
-                // don't want to dump all destructors when block is left,
-                // just the destructors associated with variables defined in this block
-                std::list< Statement * > oldDestructorStmts = dtorStmts;
-                dtorStmts = std::list<Statement *>();
-
-                compoundStmt = PolyMutator::mutate( compoundStmt );
-                std::list< Statement * > & statements = compoundStmt->get_kids();
-                for ( std::list< Statement * >::iterator it = dtorStmts.begin(); it != dtorStmts.end(); ++it ) {
+        template<typename Iterator, typename OutputIterator>
+        void insertDtors( Iterator begin, Iterator end, OutputIterator out ) {
+                for ( Iterator it = begin ; it != end ; ++it ) {
                         // remove if instrinsic destructor statement
                         // xxx - test user manually calling intrinsic functions - what happens?
@@ -140 +136 @@
                                 // will call all member dtors, and some members may have a user defined dtor.
                                 if ( function->get_var()->get_linkage() == LinkageSpec::Intrinsic ) {
-                                        // don't ned to call intrinsic dtor, because it does nothing
-                                        delete *it;
+                                        // don't need to call intrinsic dtor, because it does nothing
                                 } else {
                                         // non-intrinsic dtors must be called
-                                        statements.push_back( *it );
+                                        *out++ = (*it)->clone();
                                 }
                         } else {
                                 // could also be a compound statement with a loop, in the case of an array
-                                statements.push_back( *it );
+                                *out++ = (*it)->clone();
                         }
                 }
+        }
+
+
+        CompoundStmt * FixInit::mutate( CompoundStmt * compoundStmt ) {
+                // mutate statements - this will also populate dtorStmts list.
+                // don't want to dump all destructors when block is left,
+                // just the destructors associated with variables defined in this block,
+                // so push a new list to the top of the stack so that we can differentiate scopes
+                dtorStmts.push_back( std::list<Statement *>() );
+
+                compoundStmt = PolyMutator::mutate( compoundStmt );
+                std::list< Statement * > & statements = compoundStmt->get_kids();
+
+                insertDtors( dtorStmts.back().begin(), dtorStmts.back().end(), back_inserter( statements ) );
+
+                deleteAll( dtorStmts.back() );
+                dtorStmts.pop_back();
+                return compoundStmt;
+        }
+
+        Statement * FixInit::mutate( ReturnStmt * returnStmt ) {
+                for ( std::list< std::list< Statement * > >::reverse_iterator list = dtorStmts.rbegin(); list != dtorStmts.rend(); ++list ) {
+                        insertDtors( list->begin(), list->end(), back_inserter( stmtsToAdd ) );
+                }
+                return returnStmt;
+        }
+
+        Statement * FixInit::mutate( BranchStmt * branchStmt ) {
                 // TODO: adding to the end of a block isn't sufficient, since
                 // return/break/goto should trigger destructor when block is left.
-                dtorStmts = oldDestructorStmts;
-                return compoundStmt;
-        }
+                switch( branchStmt->get_type() ) {
+                        case BranchStmt::Continue:
+                        case BranchStmt::Break:
+                                insertDtors( dtorStmts.back().begin(), dtorStmts.back().end(), back_inserter( stmtsToAdd ) );
+                                break;
+                        case BranchStmt::Goto:
+                                // xxx
+                                // if goto leaves a block, generate dtors for every block it leaves
+                                // if goto is in same block but earlier statement, destruct every object that was defined after the statement
+                                break;
+                        default:
+                                assert( false );
+                }
+                return branchStmt;
+        }
+
 
 } // namespace InitTweak