Changeset 4d2434a

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

Location:

src

Files:

• CodeGen/CodeGenerator.cc (modified) (1 diff)
• InitTweak/GenInit.cc (modified) (2 diffs)
• InitTweak/InitTweak.cc (modified) (9 diffs)
• InitTweak/InitTweak.h (modified) (2 diffs)
• ResolvExpr/Resolver.cc (modified) (3 diffs)
• SymTab/Autogen.h (modified) (8 diffs)
• SynTree/Initializer.h (modified) (1 diff)

src/CodeGen/CodeGenerator.cc

@@ -270 +270 @@
                 printDesignators( init->get_designators() );
                 output << "{ ";
-                if ( init->begin_initializers() == init->end_initializers() ) {
+                if ( init->begin() == init->end() ) {
                         // illegal to leave initializer list empty for scalar initializers, but always legal to have 0
                         output << "0";
                 } else {
-                        genCommaList( init->begin_initializers(), init->end_initializers() );
+                        genCommaList( init->begin(), init->end() );
                 }
                 output << " }";

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() ) );
                         }
                 }

src/InitTweak/InitTweak.cc

@@ +1 @@
+#include <algorithm>
 #include "InitTweak.h"
 #include "SynTree/Visitor.h"
@@ -20 +21 @@
                 };
 
-                class InitExpander_OLD : public Visitor {
+                class InitFlattener : public Visitor {
                         public:
                         virtual void visit( SingleInit * singleInit );
@@ -27 +28 @@
                 };
 
-                void InitExpander_OLD::visit( SingleInit * singleInit ) {
+                void InitFlattener::visit( SingleInit * singleInit ) {
                         argList.push_back( singleInit->get_value()->clone() );
                 }
 
-                void InitExpander_OLD::visit( ListInit * listInit ) {
-                        // xxx - for now, assume no nested list inits
-                        std::list<Initializer*>::iterator it = listInit->begin_initializers();
-                        for ( ; it != listInit->end_initializers(); ++it ) {
+                void InitFlattener::visit( ListInit * listInit ) {
+                        // flatten nested list inits
+                        std::list<Initializer*>::iterator it = listInit->begin();
+                        for ( ; it != listInit->end(); ++it ) {
                                 (*it)->accept( *this );
                         }
@@ -41 +42 @@
 
         std::list< Expression * > makeInitList( Initializer * init ) {
-                InitExpander_OLD expander;
-                maybeAccept( init, expander );
-                return expander.argList;
+                InitFlattener flattener;
+                maybeAccept( init, flattener );
+                return flattener.argList;
         }
 
@@ -55 +56 @@
         public:
                 virtual std::list< Expression * > next( std::list< Expression * > & indices ) = 0;
+                virtual Statement * buildListInit( UntypedExpr * callExpr, std::list< Expression * > & indices ) = 0;
         };
 
         class InitImpl : public InitExpander::ExpanderImpl {
         public:
-                InitImpl( Initializer * init ) {
-                        if ( init ) inits.push_back( init );
-                }
+                InitImpl( Initializer * init ) : init( 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 * >();
-                }
+                        // if ( ! flattened ) flatten( indices );
+                        // return ! inits.empty() ? makeInitList( inits.front() ) : std::list< Expression * >();
+                        return makeInitList( init );
+                }
+
+                virtual Statement * buildListInit( UntypedExpr * callExpr, std::list< Expression * > & indices );
         private:
-                std::list< Initializer * > inits;
+                Initializer * init;
         };
 
@@ -91 +95 @@
                         return ret;
                 }
+
+                virtual Statement * buildListInit( UntypedExpr * callExpr, std::list< Expression * > & indices );
         private:
                 Expression * arg;
@@ -114 +120 @@
         }
 
-        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
+        void InitExpander::clearArrayIndices() {
+                indices.clear();
+        }
+
+        namespace {
+                template< typename OutIterator >
+                void dothething( UntypedExpr * callExpr, Expression * index, Expression * dimension, Initializer * init, OutIterator out ) {
+                        UntypedExpr * cond = new UntypedExpr( new NameExpr( "?<?") );
+                        cond->get_args().push_back( index->clone() );
+                        cond->get_args().push_back( dimension->clone() );
+
+                        std::list< Expression * > args = makeInitList( init );
+                        callExpr->get_args().splice( callExpr->get_args().end(), args );
+
+                        *out++ = new IfStmt( noLabels, cond, new ExprStmt( noLabels, callExpr ), NULL );
+
+                        UntypedExpr * increment = new UntypedExpr( new NameExpr( "++?" ) );
+                        increment->get_args().push_back( new AddressExpr( index->clone() ) );
+                        *out++ = new ExprStmt( noLabels, increment );
+                }
+
+                template< typename OutIterator >
+                void build( UntypedExpr * callExpr, InitExpander::IndexList::iterator idx, InitExpander::IndexList::iterator idxEnd, Initializer * init, OutIterator out ) {
+                        if ( idx == idxEnd ) return;
+                        Expression * index = *idx++;
+                        assert( idx != idxEnd );
+                        Expression * dimension = *idx++;
+
+                        if ( idx == idxEnd ) {
+                                if ( ListInit * listInit = dynamic_cast< ListInit * >( init ) ) {
+                                        for ( Initializer * init : *listInit ) {
+                                                dothething( callExpr->clone(), index, dimension, init, out );
+                                        }
+                                } else {
+                                        dothething( callExpr->clone(), index, dimension, init, out );
+                                }
+                        } else {
+                                std::list< Statement * > branches;
+
+                                unsigned long cond = 0;
+                                ListInit * listInit = dynamic_cast< ListInit * >( init );
+                                if ( ! listInit ) {
+                                        // xxx - this shouldn't be an error, but need a way to
+                                        // terminate without creating output, so should catch this error
+                                        throw SemanticError( "unbalanced list initializers" );
+                                }
+                                for ( Initializer * init : *listInit ) {
+                                        Expression * condition;
+                                        // check for designations
+                                        // if ( init-> ) {
+                                                condition = new ConstantExpr( Constant::from_ulong( cond ) );
+                                                ++cond;
+                                        // } else {
+                                        //      condition = // ... take designation
+                                        //      cond = // ... take designation+1
+                                        // }
+                                        std::list< Statement * > stmts;
+                                        build( callExpr, idx, idxEnd, init, back_inserter( stmts ) );
+                                        CaseStmt * caseStmt = new CaseStmt( noLabels, condition, stmts );
+                                        branches.push_back( caseStmt );
+                                }
+                                *out++ = new SwitchStmt( noLabels, index->clone(), branches );
+                        }
+                }
+        }
+
+        // if 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.
+        // 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
+        Statement * InitImpl::buildListInit( UntypedExpr * dst, std::list< Expression * > & indices ) {
+                if ( ! init ) return NULL;
+                std::list< Statement * > results;
+                build( dst, indices.begin(), indices.end(), init, back_inserter( results ) );
+                assert( results.size() <= 1 );
+                if ( results.empty() ) {
+                        return NULL;
+                } else {
+                        init = NULL; // init was consumed in creating the list init
+                        return results.front();
+                }
+                return ! results.empty() ? results.front() : NULL;
+        }
+
+        Statement * ExprImpl::buildListInit( UntypedExpr * dst, std::list< Expression * > & indices ) {
+                return NULL;
+        }
+
         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;
+                return expander->buildListInit( dst, indices );
         }
 
@@ -164 +222 @@
         }
 
+        class CallFinder : public Visitor {
+        public:
+                typedef Visitor Parent;
+                CallFinder( const std::list< std::string > & names ) : names( names ) {}
+
+                virtual void visit( ApplicationExpr * appExpr ) {
+                        handleCallExpr( appExpr );
+                }
+
+                virtual void visit( UntypedExpr * untypedExpr ) {
+                        handleCallExpr( untypedExpr );
+                }
+
+                std::list< Expression * > * matches;
+        private:
+                const std::list< std::string > names;
+
+                template< typename CallExpr >
+                void handleCallExpr( CallExpr * expr ) {
+                        Parent::visit( expr );
+                        std::string fname = getFunctionName( expr );
+                        if ( std::find( names.begin(), names.end(), fname ) != names.end() ) {
+                                matches->push_back( expr );
+                        }
+                }
+        };
+
+        void collectCtorDtorCalls( Statement * stmt, std::list< Expression * > & matches ) {
+                static CallFinder finder( std::list< std::string >{ "?{}", "^?{}" } );
+                finder.matches = &matches;
+                maybeAccept( stmt, finder );
+        }
+
         Expression * getCtorDtorCall( Statement * stmt ) {
-                if ( stmt == NULL ) return NULL;
-                if ( ExprStmt * exprStmt = dynamic_cast< ExprStmt * >( stmt ) ) {
-                        return exprStmt->get_expr();
-                } else if ( CompoundStmt * compoundStmt = dynamic_cast< CompoundStmt * >( stmt ) ) {
-                        // could also be a compound statement with a loop, in the case of an array
-                        if( compoundStmt->get_kids().size() == 2 ) {
-                                // loop variable and loop
-                                ForStmt * forStmt = dynamic_cast< ForStmt * >( compoundStmt->get_kids().back() );
-                                assert( forStmt && forStmt->get_body() );
-                                return getCtorDtorCall( forStmt->get_body() );
-                        } else if ( compoundStmt->get_kids().size() == 1 ) {
-                                // should be the call statement, but in any case there's only one option
-                                return getCtorDtorCall( compoundStmt->get_kids().front() );
-                        } else {
-                                assert( false && "too many statements in compoundStmt for getCtorDtorCall" );
-                        }
-                } if ( ImplicitCtorDtorStmt * impCtorDtorStmt = dynamic_cast< ImplicitCtorDtorStmt * > ( stmt ) ) {
-                        return getCtorDtorCall( impCtorDtorStmt->get_callStmt() );
-                } else {
-                        // should never get here
-                        assert( false && "encountered unknown call statement" );
-                }
-        }
+                std::list< Expression * > matches;
+                collectCtorDtorCalls( stmt, matches );
+                assert( matches.size() <= 1 );
+                return matches.size() == 1 ? matches.front() : NULL;
+        }
+
         namespace {
                 VariableExpr * getCalledFunction( ApplicationExpr * appExpr ) {
                         assert( appExpr );
+                        // xxx - it's possible this can be other things, e.g. MemberExpr, so this is insufficient
                         return dynamic_cast< VariableExpr * >( appExpr->get_function() );
                 }
@@ -206 +281 @@
 
         bool isInstrinsicSingleArgCallStmt( Statement * stmt ) {
-                Expression * callExpr = getCtorDtorCall( stmt );
-                if ( ! callExpr ) return false;
-                if ( ApplicationExpr * appExpr = isIntrinsicCallExpr( callExpr ) ) {
-                        assert( ! appExpr->get_function()->get_results().empty() );
-                        FunctionType *funcType = GenPoly::getFunctionType( appExpr->get_function()->get_results().front() );
-                        assert( funcType );
-                        return funcType->get_parameters().size() == 1;
-                }
-                return false;
+                std::list< Expression * > callExprs;
+                collectCtorDtorCalls( stmt, callExprs );
+                // if ( callExprs.empty() ) return false; // xxx - do I still need this check?
+                return std::all_of( callExprs.begin(), callExprs.end(), []( Expression * callExpr ){
+                        if ( ApplicationExpr * appExpr = isIntrinsicCallExpr( callExpr ) ) {
+                                assert( ! appExpr->get_function()->get_results().empty() );
+                                FunctionType *funcType = GenPoly::getFunctionType( appExpr->get_function()->get_results().front() );
+                                assert( funcType );
+                                return funcType->get_parameters().size() == 1;
+                        }
+                        return false;
+                });
         }
 

src/InitTweak/InitTweak.h

@@ -43 +43 @@
         bool isInstrinsicSingleArgCallStmt( Statement * expr );
 
+        /// get all Ctor/Dtor call expressions from a Statement
+        void collectCtorDtorCalls( Statement * stmt, std::list< Expression * > & matches );
+
         /// get the Ctor/Dtor call expression from a Statement that looks like a generated ctor/dtor call
         Expression * getCtorDtorCall( Statement * stmt );
@@ -78 +81 @@
                 Statement * buildListInit( UntypedExpr * callExpr );
                 void addArrayIndex( Expression * index, Expression * dimension );
+                void clearArrayIndices();
 
                 class ExpanderImpl;

src/ResolvExpr/Resolver.cc

@@ -54 +54 @@
                 virtual void visit( BranchStmt *branchStmt );
                 virtual void visit( ReturnStmt *returnStmt );
-                virtual void visit( ImplicitCtorDtorStmt * impCtorDtorStmt );
 
                 virtual void visit( SingleInit *singleInit );
@@ -436 +435 @@
 
         void Resolver::visit( ListInit * listInit ) {
-                InitIterator iter = listInit->begin_initializers();
-                InitIterator end = listInit->end_initializers();
+                InitIterator iter = listInit->begin();
+                InitIterator end = listInit->end();
 
                 if ( ArrayType * at = dynamic_cast< ArrayType * >( initContext ) ) {
@@ -539 +538 @@
                         ctorInit->set_ctor( NULL );
                 }
-                if ( InitTweak::isInstrinsicSingleArgCallStmt( ctorInit->get_ctor() ) ) {
+                if ( InitTweak::isInstrinsicSingleArgCallStmt( ctorInit->get_dtor() ) ) {
                         delete ctorInit->get_dtor();
                         ctorInit->set_dtor( NULL );
                 }
-        }
-
-        void Resolver::visit( ImplicitCtorDtorStmt * impCtorDtorStmt ) {
-                // before resolving ctor/dtor, need to remove type qualifiers from the first argument (the object being constructed).
-                // Do this through a cast expression to greatly simplify the code.
-                Expression * callExpr = InitTweak::getCtorDtorCall( impCtorDtorStmt );
-                assert( callExpr );
-                Expression *& constructee = InitTweak::getCallArg( callExpr, 0 );
-
-                // the first argument will always be &<expr>
-                AddressExpr * addrExpr = dynamic_cast< AddressExpr * > ( constructee );
-                assert( addrExpr );
-
-                // need to find the type of the first argument. In the case of an array,
-                // need to remove one ArrayType layer from the type for each subscript expression.
-                Expression * addressee = addrExpr->get_arg();
-                int numLayers = 0;
-                while ( UntypedExpr * untypedExpr = dynamic_cast< UntypedExpr * >( addressee ) ) {
-                        assert( InitTweak::getFunctionName( untypedExpr ) == "?[?]" );
-                        addressee = InitTweak::getCallArg( untypedExpr, 0 );
-                        numLayers++;
-                }
-                assert( addressee->get_results().size() == 1 );
-                Type * type = addressee->get_results().front();
-                for ( int i = 0; i < numLayers; i++ ) {
-                        type = InitTweak::getPointerBase( type );
-                        assert( type && "Expected pointer or array type. May have generated too many ?[?] calls." );
-                }
-
-                // cast to T* with qualifiers removed.
-                // unfortunately, lvalue is considered a qualifier. For AddressExpr to resolve, its argument
-                // must have an lvalue qualified type, so remove all qualifiers except lvalue. If we ever
-                // remove lvalue as a qualifier, this can change to
-                //   type->get_qualifiers() = Type::Qualifiers();
-                assert( type );
-                type = type->clone();
-                type->get_qualifiers() -= Type::Qualifiers(true, true, true, false, true, true);
-                type = new PointerType( Type::Qualifiers(), type );
-                constructee = new CastExpr( constructee, type );
-
-                // finally, resolve the ctor/dtor
-                impCtorDtorStmt->get_callStmt()->accept( *this );
         }
 } // namespace ResolvExpr

src/SymTab/Autogen.h

@@ -37 +37 @@
         /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls.
         template< typename OutputIterator >
-        void genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool forward = true );
+        void genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast = false, bool forward = true );
 
         /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Should only be called with non-array types.
         template< typename OutputIterator >
-        void genScalarCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out ) {
+        void genScalarCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast = false ) {
                 // want to be able to generate assignment, ctor, and dtor generically,
                 // so fname is either ?=?, ?{}, or ^?{}
@@ -47 +47 @@
 
                 // do something special for unnamed members
-                fExpr->get_args().push_back( new AddressExpr( dstParam ) );
+                dstParam = new AddressExpr( dstParam );
+                if ( addCast ) {
+                        // cast to T* with qualifiers removed, so that qualified objects can be constructed
+                        // and destructed with the same functions as non-qualified objects.
+                        // unfortunately, lvalue is considered a qualifier. For AddressExpr to resolve, its argument
+                        // must have an lvalue qualified type, so remove all qualifiers except lvalue. If we ever
+                        // remove lvalue as a qualifier, this can change to
+                        //   type->get_qualifiers() = Type::Qualifiers();
+                        assert( type );
+                        Type * castType = type->clone();
+                        castType->get_qualifiers() -= Type::Qualifiers(true, true, true, false, true, true);
+                        castType->set_isLvalue( true ); // xxx - might not need this
+                        dstParam = new CastExpr( dstParam, new PointerType( Type::Qualifiers(), castType ) );
+                }
+                fExpr->get_args().push_back( dstParam );
 
     Statement * listInit = srcParam.buildListInit( fExpr );
@@ -56 +70 @@
     std::list< Expression * > args = *++srcParam;
     fExpr->get_args().splice( fExpr->get_args().end(), args );
-/*              if ( srcParam ) {
-                        // xxx -
-                        // make srcParam more complicated
-                        // if srcParam contains
-                        fExpr->get_args().push_back( srcParam );
-                }
-*/
+
                 *out++ = new ExprStmt( noLabels, fExpr );
+
+    srcParam.clearArrayIndices();
         }
 
@@ -69 +79 @@
         /// If forward is true, loop goes from 0 to N-1, else N-1 to 0
         template< typename OutputIterator >
-        void genArrayCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, ArrayType *array, bool forward = true ) {
+        void genArrayCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, ArrayType *array, bool addCast = false, bool forward = true ) {
                 static UniqueName indexName( "_index" );
 
@@ -124 +134 @@
                 // for stmt's body, eventually containing call
                 CompoundStmt * body = new CompoundStmt( noLabels );
-                genCall( srcParam, dstParam, fname, back_inserter( body->get_kids() ), array->get_base(), forward );
+                genCall( srcParam, dstParam, fname, back_inserter( body->get_kids() ), array->get_base(), addCast, forward );
 
                 // block containing for stmt and index variable
@@ -136 +146 @@
 
         template< typename OutputIterator >
-        void genCall( InitTweak::InitExpander &  srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool forward ) {
+        void genCall( InitTweak::InitExpander &  srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast, bool forward ) {
                 if ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) {
-                        genArrayCall( srcParam, dstParam, fname, out, at, forward );
+                        genArrayCall( srcParam, dstParam, fname, out, at, addCast, forward );
                 } else {
-                        genScalarCall( srcParam, dstParam, fname, out );
+                        genScalarCall( srcParam, dstParam, fname, out, type, addCast );
                 }
         }
@@ -155 +165 @@
                 if ( isUnnamedBitfield( obj ) ) return;
 
+                bool addCast = (fname == "?{}" || fname == "^?{}") && ( !obj || ( obj && obj->get_bitfieldWidth() == NULL ) );
                 std::list< Statement * > stmts;
-                genCall( srcParam, dstParam, fname, back_inserter( stmts ), obj->get_type(), forward );
+                genCall( srcParam, dstParam, fname, back_inserter( stmts ), obj->get_type(), addCast, forward );
 
                 // currently genCall should produce at most one element, but if that changes then the next line needs to be updated to grab the statement which contains the call
@@ -162 +173 @@
     if ( stmts.size() == 1 ) {
                 Statement * callStmt = stmts.front();
-                if ( (fname == "?{}" || fname == "^?{}") && ( !obj || ( obj && obj->get_bitfieldWidth() == NULL ) ) ) {
+                if ( addCast ) {
                         // implicitly generated ctor/dtor calls should be wrapped
                         // so that later passes are aware they were generated.

src/SynTree/Initializer.h

@@ -93 +93 @@
         std::list<Initializer*> &get_initializers() { return initializers; }
 
-        std::list<Initializer*>::iterator begin_initializers() { return initializers.begin(); }
-        std::list<Initializer*>::iterator end_initializers() { return initializers.end(); }
+        typedef std::list<Initializer*>::iterator iterator;
+        iterator begin() { return initializers.begin(); }
+        iterator end() { return initializers.end(); }
 
         virtual ListInit *clone() const { return new ListInit( *this ); }