Index: src/SymTab/Autogen.h
===================================================================
--- src/SymTab/Autogen.h	(revision d56e5bcda08aa6816d20a750cfe4087387b7681f)
+++ src/SymTab/Autogen.h	(revision cd99ef1f70d999e3d215bb166749d82f67bd56e6)
@@ -25,21 +25,21 @@
 
 namespace SymTab {
-    /// Generates assignment operators, constructors, and destructor for aggregate types as required
-    void autogenerateRoutines( std::list< Declaration * > &translationUnit );
+	/// Generates assignment operators, constructors, and destructor for aggregate types as required
+	void autogenerateRoutines( std::list< Declaration * > &translationUnit );
 
-    /// returns true if obj's name is the empty string and it has a bitfield width
-    bool isUnnamedBitfield( ObjectDecl * obj );
+	/// returns true if obj's name is the empty string and it has a bitfield width
+	bool isUnnamedBitfield( ObjectDecl * obj );
 
-    /// size_t type - set when size_t typedef is seen. Useful in a few places,
-    /// such as in determining array dimension type
-    extern Type * SizeType;
+	/// size_t type - set when size_t typedef is seen. Useful in a few places,
+	/// such as in determining array dimension type
+	extern Type * SizeType;
 
-    /// 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 >
+	/// 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 >
 	Statement * 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.
-    /// optionally returns a statement which must be inserted prior to the containing loop, if there is one
-    template< typename OutputIterator >
+	/// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Should only be called with non-array types.
+	/// optionally returns a statement which must be inserted prior to the containing loop, if there is one
+	template< typename OutputIterator >
 	Statement * 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,
@@ -50,16 +50,15 @@
 	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, false);
-	    castType->get_qualifiers() -= Type::Qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Atomic );
-	    castType->set_lvalue( true ); // xxx - might not need this
-	    dstParam = new CastExpr( dstParam, new PointerType( Type::Qualifiers(), castType ) );
+		// 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( Type::Const | Type::Volatile | Type::Restrict | Type::Atomic );
+		castType->set_lvalue( true ); // xxx - might not need this
+		dstParam = new CastExpr( dstParam, new PointerType( Type::Qualifiers(), castType ) );
 	}
 	fExpr->get_args().push_back( dstParam );
@@ -75,103 +74,103 @@
 
 	return listInit;
-    }
-
-    /// Store in out a loop which calls fname on each element of the array with srcParam and dstParam as arguments.
-    /// 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 addCast = false, bool forward = true ) {
-	static UniqueName indexName( "_index" );
-
-	// for a flexible array member nothing is done -- user must define own assignment
-	if ( ! array->get_dimension() ) return ;
-
-	Expression * begin, * end, * update, * cmp;
-	if ( forward ) {
-	    // generate: for ( int i = 0; i < N; ++i )
-	    begin = new ConstantExpr( Constant::from_int( 0 ) );
-	    end = array->get_dimension()->clone();
-	    cmp = new NameExpr( "?<?" );
-	    update = new NameExpr( "++?" );
-	} else {
-	    // generate: for ( int i = N-1; i >= 0; --i )
-	    begin = new UntypedExpr( new NameExpr( "?-?" ) );
-	    ((UntypedExpr*)begin)->get_args().push_back( array->get_dimension()->clone() );
-	    ((UntypedExpr*)begin)->get_args().push_back( new ConstantExpr( Constant::from_int( 1 ) ) );
-	    end = new ConstantExpr( Constant::from_int( 0 ) );
-	    cmp = new NameExpr( "?>=?" );
-	    update = new NameExpr( "--?" );
 	}
 
-	ObjectDecl *index = new ObjectDecl( indexName.newName(), Type::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), new SingleInit( begin, std::list<Expression*>() ) );
+	/// Store in out a loop which calls fname on each element of the array with srcParam and dstParam as arguments.
+	/// 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 addCast = false, bool forward = true ) {
+		static UniqueName indexName( "_index" );
 
-	UntypedExpr *cond = new UntypedExpr( cmp );
-	cond->get_args().push_back( new VariableExpr( index ) );
-	cond->get_args().push_back( end );
+		// for a flexible array member nothing is done -- user must define own assignment
+		if ( ! array->get_dimension() ) return ;
 
-	UntypedExpr *inc = new UntypedExpr( update );
-	inc->get_args().push_back( new AddressExpr( new VariableExpr( index ) ) );
+		Expression * begin, * end, * update, * cmp;
+		if ( forward ) {
+			// generate: for ( int i = 0; i < N; ++i )
+			begin = new ConstantExpr( Constant::from_int( 0 ) );
+			end = array->get_dimension()->clone();
+			cmp = new NameExpr( "?<?" );
+			update = new NameExpr( "++?" );
+		} else {
+			// generate: for ( int i = N-1; i >= 0; --i )
+			begin = new UntypedExpr( new NameExpr( "?-?" ) );
+			((UntypedExpr*)begin)->get_args().push_back( array->get_dimension()->clone() );
+			((UntypedExpr*)begin)->get_args().push_back( new ConstantExpr( Constant::from_int( 1 ) ) );
+			end = new ConstantExpr( Constant::from_int( 0 ) );
+			cmp = new NameExpr( "?>=?" );
+			update = new NameExpr( "--?" );
+		}
 
-	UntypedExpr *dstIndex = new UntypedExpr( new NameExpr( "?[?]" ) );
-	dstIndex->get_args().push_back( dstParam );
-	dstIndex->get_args().push_back( new VariableExpr( index ) );
-	dstParam = dstIndex;
+		ObjectDecl *index = new ObjectDecl( indexName.newName(), Type::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), new SingleInit( begin ) );
 
-	// 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() );
+		UntypedExpr *cond = new UntypedExpr( cmp );
+		cond->get_args().push_back( new VariableExpr( index ) );
+		cond->get_args().push_back( end );
 
-	// for stmt's body, eventually containing call
-	CompoundStmt * body = new CompoundStmt( noLabels );
-	Statement * listInit = genCall( srcParam, dstParam, fname, back_inserter( body->get_kids() ), array->get_base(), addCast, forward );
+		UntypedExpr *inc = new UntypedExpr( update );
+		inc->get_args().push_back( new AddressExpr( new VariableExpr( index ) ) );
 
-	// block containing for stmt and index variable
-	std::list<Statement *> initList;
-	CompoundStmt * block = new CompoundStmt( noLabels );
-	block->get_kids().push_back( new DeclStmt( noLabels, index ) );
-	if ( listInit ) block->get_kids().push_back( listInit );
-	block->get_kids().push_back( new ForStmt( noLabels, initList, cond, inc, body ) );
+		UntypedExpr *dstIndex = new UntypedExpr( new NameExpr( "?[?]" ) );
+		dstIndex->get_args().push_back( dstParam );
+		dstIndex->get_args().push_back( new VariableExpr( index ) );
+		dstParam = dstIndex;
 
-	*out++ = block;
-    }
+		// 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() );
 
-    template< typename OutputIterator >
+		// for stmt's body, eventually containing call
+		CompoundStmt * body = new CompoundStmt( noLabels );
+		Statement * listInit = genCall( srcParam, dstParam, fname, back_inserter( body->get_kids() ), array->get_base(), addCast, forward );
+
+		// block containing for stmt and index variable
+		std::list<Statement *> initList;
+		CompoundStmt * block = new CompoundStmt( noLabels );
+		block->get_kids().push_back( new DeclStmt( noLabels, index ) );
+		if ( listInit ) block->get_kids().push_back( listInit );
+		block->get_kids().push_back( new ForStmt( noLabels, initList, cond, inc, body ) );
+
+		*out++ = block;
+	}
+
+	template< typename OutputIterator >
 	Statement * 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, addCast, forward );
-	    return 0;
-	} else {
-	    return genScalarCall( srcParam, dstParam, fname, out, type, addCast );
+		if ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) {
+			genArrayCall( srcParam, dstParam, fname, out, at, addCast, forward );
+			return 0;
+		} else {
+			return genScalarCall( srcParam, dstParam, fname, out, type, addCast );
+		}
 	}
-    }
 
-    /// inserts into out a generated call expression to function fname with arguments dstParam
-    /// and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls. decl is the
-    /// object being constructed. The function wraps constructor and destructor calls in an
-    /// ImplicitCtorDtorStmt node.
-    template< typename OutputIterator >
+	/// inserts into out a generated call expression to function fname with arguments dstParam
+	/// and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls. decl is the
+	/// object being constructed. The function wraps constructor and destructor calls in an
+	/// ImplicitCtorDtorStmt node.
+	template< typename OutputIterator >
 	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 );
-	// unnamed bit fields are not copied as they cannot be accessed
-	if ( isUnnamedBitfield( obj ) ) return;
+		ObjectDecl *obj = dynamic_cast<ObjectDecl *>( decl );
+		assert( obj );
+		// unnamed bit fields are not copied as they cannot be accessed
+		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(), addCast, forward );
+		bool addCast = (fname == "?{}" || fname == "^?{}") && ( !obj || ( obj && obj->get_bitfieldWidth() == NULL ) );
+		std::list< Statement * > stmts;
+		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
-	assert( stmts.size() <= 1 );
-	if ( stmts.size() == 1 ) {
-	    Statement * callStmt = stmts.front();
-	    if ( addCast ) {
-		// implicitly generated ctor/dtor calls should be wrapped
-		// so that later passes are aware they were generated.
-		// xxx - don't mark as an implicit ctor/dtor if obj is a bitfield,
-		// because this causes the address to be taken at codegen, which is illegal in C.
-		callStmt = new ImplicitCtorDtorStmt( callStmt );
-	    }
-	    *out++ = callStmt;
+		// 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
+		assert( stmts.size() <= 1 );
+		if ( stmts.size() == 1 ) {
+			Statement * callStmt = stmts.front();
+			if ( addCast ) {
+				// implicitly generated ctor/dtor calls should be wrapped
+				// so that later passes are aware they were generated.
+				// xxx - don't mark as an implicit ctor/dtor if obj is a bitfield,
+				// because this causes the address to be taken at codegen, which is illegal in C.
+				callStmt = new ImplicitCtorDtorStmt( callStmt );
+			}
+			*out++ = callStmt;
+		}
 	}
-    }
 } // namespace SymTab
 #endif // AUTOGEN_H
