Changeset 4d2434a for src/InitTweak/GenInit.cc

Timestamp:

Aug 2, 2016, 6:37:08 PM (8 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:

8a443f4

Parents:

39f84a4

Message:

major reorganization of constructor generation from initializer list so that it now works with multi-dimensional arrays

File:

• src/InitTweak/GenInit.cc (modified) (2 diffs)

src/InitTweak/GenInit.cc

@@ -154 +154 @@
         }
 
+        // precompute array dimension expression, because constructor generation may duplicate it,
+        // which would be incorrect if it is a side-effecting computation.
         void HoistArrayDimension::hoistArrayDimension( std::list< Declaration * > & translationUnit ) {
                 HoistArrayDimension hoister;
@@ -215 +217 @@
                 // hands off if designated, if @=, or if extern
                 if ( tryConstruct( objDecl ) ) {
-                        if ( ArrayType * at = dynamic_cast< ArrayType * >( objDecl->get_type() ) ) {
-                                // call into makeArrayFunction from validate.cc to generate calls to ctor/dtor for each element of array
-                                // TODO: walk initializers and generate appropriate ctor if element has initializer.
-                                // Initializer could be nested (depends on the depth of the array type on the object)
-
-                                std::list< Expression * > args = makeInitList( objDecl->get_init() );
-                                if ( args.empty() ) {
-                                        std::list< Statement * > ctor;
-                                        std::list< Statement * > dtor;
-
-                                        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
-                                        // which  wraps everything that needs to happen. As such, it's technically
-                                        // possible to use a Statement ** in the above calls, but this is inherently
-                                        // unsafe, so instead we take the slightly less efficient route, but will be
-                                        // immediately informed if somehow the above assumption is broken. In this case,
-                                        // we could always wrap the list of statements at this point with a CompoundStmt,
-                                        // but it seems reasonable at the moment for this to be done by genImplicitCall
-                                        // itself. It is possible that genImplicitCall produces no statements (e.g. if
-                                        // an array type does not have a dimension). In this case, it's fine to ignore
-                                        // the object for the purposes of construction.
-                                        assert( ctor.size() == dtor.size() && ctor.size() <= 1 );
-                                        if ( ctor.size() == 1 ) {
-                                                assert( dynamic_cast< ImplicitCtorDtorStmt * > ( ctor.front() ) && dynamic_cast< ImplicitCtorDtorStmt * > ( dtor.front() ) );
-                                                objDecl->set_init( new ConstructorInit( ctor.front(), dtor.front(), objDecl->get_init() ) );
-                                        }
-                                } else {
-                                        // array came with an initializer list: initialize each element
-                                        // may have more initializers than elements in the array - need to check at each index that
-                                        // we haven't exceeded size. This requires precomputing the size because it might be a side-effecting
-                                        // computation.
-                                        // may have fewer initializers than elements in the array - need to default construct
-                                        // remaining elements.
-                                        // might be able to merge this with the case above.
-
-                                }
-                        } else {
-                                // it's sufficient to attempt to call the ctor/dtor for the given object and its initializer
-                                Expression * ctor = makeCtorDtorExpr( "?{}", objDecl, makeInitList( objDecl->get_init() ) );
-                                Expression * dtor = makeCtorDtorExpr( "^?{}", objDecl, std::list< Expression * >() );
-
+                        // call into genImplicitCall from Autogen.h to generate calls to ctor/dtor
+                        // for each constructable object
+                        std::list< Statement * > ctor;
+                        std::list< Statement * > dtor;
+
+                        InitExpander srcParam( objDecl->get_init() );
+                        InitExpander nullParam( (Initializer *)NULL );
+                        SymTab::genImplicitCall( srcParam, new VariableExpr( objDecl ), "?{}", back_inserter( ctor ), objDecl );
+                        SymTab::genImplicitCall( nullParam, new VariableExpr( objDecl ), "^?{}", front_inserter( dtor ), objDecl, false );
+
+                        // Currently genImplicitCall produces a single Statement - a CompoundStmt
+                        // which  wraps everything that needs to happen. As such, it's technically
+                        // possible to use a Statement ** in the above calls, but this is inherently
+                        // unsafe, so instead we take the slightly less efficient route, but will be
+                        // immediately informed if somehow the above assumption is broken. In this case,
+                        // we could always wrap the list of statements at this point with a CompoundStmt,
+                        // but it seems reasonable at the moment for this to be done by genImplicitCall
+                        // itself. It is possible that genImplicitCall produces no statements (e.g. if
+                        // an array type does not have a dimension). In this case, it's fine to ignore
+                        // the object for the purposes of construction.
+                        assert( ctor.size() == dtor.size() && ctor.size() <= 1 );
+                        if ( ctor.size() == 1 ) {
                                 // need to remember init expression, in case no ctors exist
                                 // if ctor does exist, want to use ctor expression instead of init
                                 // push this decision to the resolver
-                                ExprStmt * ctorStmt = new ExprStmt( noLabels, ctor );
-                                ExprStmt * dtorStmt = new ExprStmt( noLabels, dtor );
-                                objDecl->set_init( new ConstructorInit( new ImplicitCtorDtorStmt( ctorStmt ), new ImplicitCtorDtorStmt( dtorStmt ), objDecl->get_init() ) );
+                                assert( dynamic_cast< ImplicitCtorDtorStmt * > ( ctor.front() ) && dynamic_cast< ImplicitCtorDtorStmt * > ( dtor.front() ) );
+                                objDecl->set_init( new ConstructorInit( ctor.front(), dtor.front(), objDecl->get_init() ) );
                         }
                 }