Changeset b96ec83 for src/InitTweak/FixInit.cc

Timestamp:

Oct 3, 2017, 5:12:35 PM (7 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

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

Children:

6840e7c

Parents:

1bc749f (diff), b0f601fa (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'new-branch-stashed' into cleanup-dtors

File:

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

src/InitTweak/FixInit.cc

@@ -213 +213 @@
                         void emit( CodeLocation, const Params &... params );
 
-                        FunctionDecl * function = 0;
+                        FunctionDecl * function = nullptr;
                         std::set< DeclarationWithType * > unhandled;
                         std::map< DeclarationWithType *, CodeLocation > usedUninit;
-                        ObjectDecl * thisParam = 0;
+                        ObjectDecl * thisParam = nullptr;
                         bool isCtor = false; // true if current function is a constructor
-                        StructDecl * structDecl = 0;
+                        StructDecl * structDecl = nullptr;
                 };
 
@@ -750 +750 @@
                                         } else {
                                                 ImplicitCtorDtorStmt * implicit = strict_dynamic_cast< ImplicitCtorDtorStmt * > ( ctor );
-                                                ExprStmt * ctorStmt = dynamic_cast< ExprStmt * >( implicit->get_callStmt() );
+                                                ExprStmt * ctorStmt = dynamic_cast< ExprStmt * >( implicit->callStmt );
                                                 ApplicationExpr * ctorCall = nullptr;
-                                                if ( ctorStmt && (ctorCall = isIntrinsicCallExpr( ctorStmt->get_expr() )) && ctorCall->get_args().size() == 2 ) {
+                                                if ( ctorStmt && (ctorCall = isIntrinsicCallExpr( ctorStmt->expr )) && ctorCall->get_args().size() == 2 ) {
                                                         // clean up intrinsic copy constructor calls by making them into SingleInits
-                                                        objDecl->set_init( new SingleInit( ctorCall->get_args().back() ) );
-                                                        ctorCall->get_args().pop_back();
+                                                        objDecl->init = new SingleInit( ctorCall->args.back() );
+                                                        ctorCall->args.pop_back();
                                                 } else {
                                                         stmtsToAddAfter.push_back( ctor );
-                                                        objDecl->set_init( nullptr );
-                                                        ctorInit->set_ctor( nullptr );
+                                                        objDecl->init = nullptr;
+                                                        ctorInit->ctor = nullptr;
                                                 }
 
@@ -777 +777 @@
                                                 }
                                         } // if
-                                } else if ( Initializer * init = ctorInit->get_init() ) {
-                                        objDecl->set_init( init );
-                                        ctorInit->set_init( nullptr );
+                                } else if ( Initializer * init = ctorInit->init ) {
+                                        objDecl->init = init;
+                                        ctorInit->init = nullptr;
                                 } else {
                                         // no constructor and no initializer, which is okay
-                                        objDecl->set_init( nullptr );
+                                        objDecl->init = nullptr;
                                 } // if
                                 delete ctorInit;
@@ -880 +880 @@
                 }
 
+                void addIds( SymTab::Indexer & indexer, const std::list< DeclarationWithType * > & decls ) {
+                        for ( auto d : decls ) {
+                                indexer.addId( d );
+                        }
+                }
+
+                void addTypes( SymTab::Indexer & indexer, const std::list< TypeDecl * > & tds ) {
+                        for ( auto td : tds ) {
+                                indexer.addType( td );
+                                addIds( indexer, td->assertions );
+                        }
+                }
+
                 void GenStructMemberCalls::previsit( FunctionDecl * funcDecl ) {
-                        GuardValue( funcDecl );
+                        GuardValue( function );
                         GuardValue( unhandled );
                         GuardValue( usedUninit );
@@ -914 +927 @@
                 }
 
-                void addIds( SymTab::Indexer & indexer, const std::list< DeclarationWithType * > & decls ) {
-                        for ( auto d : decls ) {
-                                indexer.addId( d );
-                        }
-                }
-
-                void addTypes( SymTab::Indexer & indexer, const std::list< TypeDecl * > & tds ) {
-                        for ( auto td : tds ) {
-                                indexer.addType( td );
-                                addIds( indexer, td->assertions );
-                        }
-                }
-
                 void GenStructMemberCalls::postvisit( FunctionDecl * funcDecl ) {
                         // remove the unhandled objects from usedUninit, because a call is inserted