Index: src/InitTweak/GenInit.cc
===================================================================
--- src/InitTweak/GenInit.cc	(revision 29e8bf554f11f612dcf3d14dccfcfe21459331b0)
+++ src/InitTweak/GenInit.cc	(revision 39f84a4e271ab1b20b0bd4bae4f1ca69460c1dc7)
@@ -225,6 +225,7 @@
 					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
Index: src/InitTweak/InitTweak.cc
===================================================================
--- src/InitTweak/InitTweak.cc	(revision 29e8bf554f11f612dcf3d14dccfcfe21459331b0)
+++ src/InitTweak/InitTweak.cc	(revision 39f84a4e271ab1b20b0bd4bae4f1ca69460c1dc7)
@@ -20,7 +20,6 @@
 		};
 
-		class InitExpander : public Visitor {
+		class InitExpander_OLD : public Visitor {
 			public:
-			InitExpander() {}
 			virtual void visit( SingleInit * singleInit );
 			virtual void visit( ListInit * listInit );
@@ -28,9 +27,9 @@
 		};
 
-		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,5 +41,5 @@
 
 	std::list< Expression * > makeInitList( Initializer * init ) {
-		InitExpander expander;
+		InitExpander_OLD expander;
 		maybeAccept( init, expander );
 		return expander.argList;
@@ -51,4 +50,108 @@
 		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;
 	}
 
Index: src/InitTweak/InitTweak.h
===================================================================
--- src/InitTweak/InitTweak.h	(revision 29e8bf554f11f612dcf3d14dccfcfe21459331b0)
+++ src/InitTweak/InitTweak.h	(revision 39f84a4e271ab1b20b0bd4bae4f1ca69460c1dc7)
@@ -61,4 +61,31 @@
 	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
 
Index: src/SymTab/Autogen.cc
===================================================================
--- src/SymTab/Autogen.cc	(revision 29e8bf554f11f612dcf3d14dccfcfe21459331b0)
+++ src/SymTab/Autogen.cc	(revision 39f84a4e271ab1b20b0bd4bae4f1ca69460c1dc7)
@@ -189,9 +189,11 @@
 		}
 
+		InitTweak::InitExpander srcParam( src );
+
 		// assign to destination (and return value if generic)
 		UntypedExpr *derefExpr = new UntypedExpr( new NameExpr( "*?" ) );
 		derefExpr->get_args().push_back( new VariableExpr( dstParam ) );
 		Expression *dstselect = new MemberExpr( field, derefExpr );
-		genImplicitCall( src, dstselect, func->get_name(), back_inserter( func->get_statements()->get_kids() ), field, forward );
+		genImplicitCall( srcParam, dstselect, func->get_name(), back_inserter( func->get_statements()->get_kids() ), field, forward );
 
 		if ( isGeneric && returnVal ) {
@@ -199,5 +201,5 @@
 			derefRet->get_args().push_back( new VariableExpr( returnVal ) );
 			Expression *retselect = new MemberExpr( field, derefRet );
-			genImplicitCall( src, retselect, func->get_name(), back_inserter( func->get_statements()->get_kids() ), field, forward );
+			genImplicitCall( srcParam, retselect, func->get_name(), back_inserter( func->get_statements()->get_kids() ), field, forward );
 		} // if
 	}
Index: src/SymTab/Autogen.h
===================================================================
--- src/SymTab/Autogen.h	(revision 29e8bf554f11f612dcf3d14dccfcfe21459331b0)
+++ src/SymTab/Autogen.h	(revision 39f84a4e271ab1b20b0bd4bae4f1ca69460c1dc7)
@@ -22,4 +22,5 @@
 #include "SynTree/Declaration.h"
 #include "SynTree/Initializer.h"
+#include "InitTweak/InitTweak.h"
 
 namespace SymTab {
@@ -36,9 +37,9 @@
 	/// 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( Expression * 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 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( Expression *srcParam, Expression *dstParam, const std::string & fname, OutputIterator out ) {
+	void genScalarCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out ) {
 		// want to be able to generate assignment, ctor, and dtor generically,
 		// so fname is either ?=?, ?{}, or ^?{}
@@ -48,8 +49,18 @@
 		fExpr->get_args().push_back( new AddressExpr( dstParam ) );
 
-		if ( srcParam ) {
+    Statement * listInit = srcParam.buildListInit( fExpr );
+    if ( listInit ) {
+      *out++ = listInit;
+    }
+
+    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 );
 	}
@@ -58,5 +69,5 @@
 	/// If forward is true, loop goes from 0 to N-1, else N-1 to 0
 	template< typename OutputIterator >
-	void genArrayCall( Expression *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 forward = true ) {
 		static UniqueName indexName( "_index" );
 
@@ -100,11 +111,14 @@
 		dstParam = dstIndex;
 
-		// srcParam is NULL for default ctor/dtor
-		if ( srcParam ) {
-			UntypedExpr *srcIndex = new UntypedExpr( new NameExpr( "?[?]" ) );
-			srcIndex->get_args().push_back( srcParam );
-			srcIndex->get_args().push_back( new VariableExpr( index ) );
-			srcParam = srcIndex;
-		}
+		// srcParam must keep track of the array indices to build the
+		// source parameter and/or array list initializer
+		srcParam.addArrayIndex( new VariableExpr( index ), array->get_dimension()->clone() );
+
+		// if ( srcParam ) {
+		// 	UntypedExpr *srcIndex = new UntypedExpr( new NameExpr( "?[?]" ) );
+		// 	srcIndex->get_args().push_back( srcParam );
+		// 	srcIndex->get_args().push_back( new VariableExpr( index ) );
+		// 	srcParam = srcIndex;
+		// }
 
 		// for stmt's body, eventually containing call
@@ -122,5 +136,5 @@
 
 	template< typename OutputIterator >
-	void genCall( Expression * 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 forward ) {
 		if ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) {
 			genArrayCall( srcParam, dstParam, fname, out, at, forward );
@@ -135,5 +149,5 @@
 	/// ImplicitCtorDtorStmt node.
 	template< typename OutputIterator >
-	void genImplicitCall( Expression * srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, DeclarationWithType * decl, bool forward = true ) {
+	void genImplicitCall( InitTweak::InitExpander &  srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, DeclarationWithType * decl, bool forward = true ) {
 		ObjectDecl *obj = dynamic_cast<ObjectDecl *>( decl );
 		assert( obj );
Index: src/SynTree/Expression.cc
===================================================================
--- src/SynTree/Expression.cc	(revision 29e8bf554f11f612dcf3d14dccfcfe21459331b0)
+++ src/SynTree/Expression.cc	(revision 39f84a4e271ab1b20b0bd4bae4f1ca69460c1dc7)
@@ -344,10 +344,11 @@
 }
 
+//// is this right? It's cloning the member, but the member is a declaration so probably shouldn't be cloned...
 MemberExpr::MemberExpr( const MemberExpr &other ) :
-		Expression( other ), member( maybeClone( other.member ) ), aggregate( maybeClone( other.aggregate ) ) {
+		Expression( other ), member( other.member ), aggregate( maybeClone( other.aggregate ) ) {
 }
 
 MemberExpr::~MemberExpr() {
-	delete member;
+	// delete member;
 	delete aggregate;
 }